@plaudit/webpack-extensions 2.61.1 → 2.62.0

package/build/shared.d.ts

@@ -1,5 +1,6 @@
+import { PHPWriter } from "./utils/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import type { Configuration } from "webpack";
+import { type Configuration, type EntryOptions, WebpackError } from "webpack";
 export type RawAssetData = Record<string, {
     dependencies: string[];
     version: string;
@@ -71,7 +72,27 @@ export type PlauditWordpressWebpackConfig = {
     srcPrefixes?: string[];
     useUnifiedLoader?: boolean;
 };
-export declare function makeEmittableConfigPHP(data: any): string;
+export type SmuggledBlockEntrypointInfo = [
+    string,
+    EntrypointFields[number],
+    string,
+    string,
+    string
+];
+export type UnpackedBlockEntrypointInfo = {
+    blockJsonOrigin: string;
+    entrypointField: EntrypointFields[number];
+    originalValue: string;
+    entrypointName: string;
+    handle: string;
+};
+export declare function packBlockEntrypointInfoForSmuggling(info: UnpackedBlockEntrypointInfo): SmuggledBlockEntrypointInfo;
+export declare function unpackSmuggledBlockEntrypointInfo(library: EntryOptions['library']): UnpackedBlockEntrypointInfo | undefined;
+export declare function isSmuggledLibraryInfo(libraryName: NonNullable<EntryOptions['library']>['name'] | undefined): libraryName is SmuggledBlockEntrypointInfo;
+export declare function makeEmittableConfigPHP(data: any, asFullFile: boolean, parentIndent?: string): string;
+export type EntrypointFields = ["viewScriptModule", "scriptModule"] | ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];
+export declare const entrypointFields: ReadonlyArray<EntrypointFields[number]>;
+export declare function convertEntrypointFieldForAssetType(entrypointField: EntrypointFields[number], assetType: 'script' | 'style'): EntrypointFields[number];
 export type Sync<V> = {
     sync: Promise<V>;
     resolve(v: V): void;
@@ -92,9 +113,19 @@ export declare const scriptExtension: RegExp;
 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 scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "" | "style" | "script";
+export declare function isStyleField(field: string): boolean;
+export declare function isScriptModuleField(field: string): boolean;
 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]>;
+export declare function arrayIsLength<T, N extends number>(arr: T[] | null | undefined, length: N): arr is TupleOf<T, N>;
 export declare function kebabCase(value: string): string;
 export declare function loadEnvFile(filePath: string): Promise<Record<string, string>>;
 export declare function parseEnvFile(contents: string): Record<string, string>;
+export declare function newWebpackErrorForFile(error: string, file: string): WebpackError;
+/**
+ * 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 {};

package/build/shared.js

@@ -3,18 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.styleExtension = exports.scriptWithModuleExtension = exports.scriptWithoutModuleExtension = exports.scriptExtension = exports.SyncsManager = exports.standardLocationNames = void 0;
+exports.styleExtension = exports.scriptWithModuleExtension = exports.scriptWithoutModuleExtension = exports.scriptExtension = exports.SyncsManager = exports.entrypointFields = exports.standardLocationNames = void 0;
 exports.isRawAssetData = isRawAssetData;
 exports.determineCurrentSourceType = determineCurrentSourceType;
+exports.packBlockEntrypointInfoForSmuggling = packBlockEntrypointInfoForSmuggling;
+exports.unpackSmuggledBlockEntrypointInfo = unpackSmuggledBlockEntrypointInfo;
+exports.isSmuggledLibraryInfo = isSmuggledLibraryInfo;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
+exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
 exports.leadingSlashIt = leadingSlashIt;
 exports.scriptOrStyleTest = scriptOrStyleTest;
+exports.isStyleField = isStyleField;
+exports.isScriptModuleField = isScriptModuleField;
 exports.hasAtLeastOneItem = hasAtLeastOneItem;
+exports.arrayIsLength = arrayIsLength;
 exports.kebabCase = kebabCase;
 exports.loadEnvFile = loadEnvFile;
 exports.parseEnvFile = parseEnvFile;
-const json_to_php_but_with____injection_1 = __importDefault(require("./utils/json-to-php-but-with-__-injection"));
+exports.newWebpackErrorForFile = newWebpackErrorForFile;
+exports.emitResolveBaseUriFunction = emitResolveBaseUriFunction;
 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) {
     if (!thing || typeof thing !== 'object') {
         return false;
@@ -45,13 +56,36 @@ function determineCurrentSourceType(dest, srcIsDirectory) {
         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(", ")}]`)
-        + ";";
+function packBlockEntrypointInfoForSmuggling(info) {
+    return [info.blockJsonOrigin, info.entrypointField, info.originalValue, info.entrypointName, info.handle];
+}
+function unpackSmuggledBlockEntrypointInfo(library) {
+    const libraryName = library?.name;
+    if (!isSmuggledLibraryInfo(libraryName)) {
+        return undefined;
+    }
+    return { blockJsonOrigin: libraryName[0], entrypointField: libraryName[1], originalValue: libraryName[2], entrypointName: libraryName[3], handle: libraryName[4] };
+}
+function isSmuggledLibraryInfo(libraryName) {
+    if (!Array.isArray(libraryName) || !arrayIsLength(libraryName, 5) || libraryName.some(item => typeof item !== 'string')) {
+        return false;
+    }
+    return libraryName[0].endsWith("/block.json") && exports.entrypointFields.includes(libraryName[1]);
+}
+function makeEmittableConfigPHP(data, asFullFile, parentIndent = "") {
+    const prettyPrintedMetadata = json_to_php_but_with____injection_1.default.make({ indent: "\t", linebreak: "\n", shortArraySyntax: true })(data, parentIndent)
+        .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(", ")}]`);
+    return asFullFile ? `<?php return ${prettyPrintedMetadata};` : prettyPrintedMetadata.trim();
+}
+exports.entrypointFields = [
+    "editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script", "viewScriptModule", "scriptModule"
+];
+function convertEntrypointFieldForAssetType(entrypointField, assetType) {
+    // Using these word fragments instead of the full words allows us to avoid having to deal with the capitalization of the first letter
+    const searchRep = assetType === 'script' ? ['tyle', 'cript'] : ['cript', 'tyle'];
+    return entrypointField.replace(...searchRep);
 }
 class SyncsManager {
     readinessMapping = new Map();
@@ -83,9 +117,18 @@ exports.styleExtension = /(?<filename>.+)(?<extension>\.(p?c|sa)ss)$/i;
 function scriptOrStyleTest(entryPath, scriptExtension) {
     return scriptExtension.test(entryPath) ? "script" : (exports.styleExtension.test(entryPath) ? "style" : "");
 }
+function isStyleField(field) {
+    return field.endsWith("tyle");
+}
+function isScriptModuleField(field) {
+    return field.includes("odule");
+}
 function hasAtLeastOneItem(list) {
     return list.length > 0;
 }
+function arrayIsLength(arr, length) {
+    return !!arr && arr.length === length;
+}
 function kebabCase(value) {
     const kebabCaseRegexes = [[/([a-z])([A-Z])/g, "$1-$2"], [/[\s_.\-]+/g, "-"]];
     return kebabCaseRegexes.reduce((str, [pattern, replacement]) => str.replace(pattern, replacement), value).toLowerCase();
@@ -101,3 +144,29 @@ function parseEnvFile(contents) {
         return equalsPos === -1 ? [line, ""] : [line.substring(0, equalsPos), line.substring(equalsPos + 1)];
     }));
 }
+function newWebpackErrorForFile(error, file) {
+    const res = new webpack_1.WebpackError(error);
+    res.hideStack = true;
+    res.file = file;
+    return res;
+}
+/**
+ * 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
+ */
+function 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 });
+}

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

@@ -1,4 +1,4 @@
-import { PlauditWordpressWebpackConfig, VerifiedAdvancedOutputConfig } from "../shared";
+import { EntrypointFields, PlauditWordpressWebpackConfig, VerifiedAdvancedOutputConfig } 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'>> & {
@@ -10,7 +10,7 @@ export type CommonPluginConfig = {
     removeEmptyScriptsPlugin: WebpackRemoveEmptyScriptsPlugin;
 };
 export type CommonConfigProcessingResult = {
-    entrypointFields: string[];
+    entrypointFields: EntrypointFields;
     fixedRules: NonNullable<Configuration['module']>['rules'];
     processingModules: boolean;
     scriptExtension: RegExp;

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

@@ -10,7 +10,6 @@ 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 BlockJSONManagingPlugin_1 = require("../plugins/BlockJSONManagingPlugin");
 const shared_1 = require("../shared");
 const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
 let isInThemeCache = undefined;
@@ -34,20 +33,20 @@ function groupEntrypointsByAssetFile(entrypoints, entrypointNameExtractor) {
     }
     return seenPaths;
 }
-function mapToRealEntrypoints(entrypoint, dir, args = {}) {
-    const { mapper = ep => ep, lazyDependent, associatedQuery, destDir } = args;
+function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args = {}) {
+    const { mapper = ep => ep, destDir } = args;
     return (Array.isArray(entrypoint) ? entrypoint : [entrypoint])
         .map(ep => joinPossiblyAbsolutePaths(dir, mapper(ep)))
-        .filter(ep => node_fs_1.default.statSync(ep, { throwIfNoEntry: false })?.isFile())
+        .filter(ep => supportedExtensions(ep) && node_fs_1.default.statSync(ep, { throwIfNoEntry: false })?.isFile())
         .map(ep => {
         const parsedEntrypoint = node_path_1.default.parse(ep);
-        return [joinPossiblyAbsolutePaths(destDir, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name), { import: ep, lazyDependent, associatedQuery }];
+        return [joinPossiblyAbsolutePaths(destDir, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name), { import: ep }];
     });
 }
-function parseEntrypointsJSON(dir, dest) {
+function parseEntrypointsJSON(dir, dest, supportedExtensions) {
     const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'entrypoints.json'), 'utf8'));
     if (Array.isArray(entrypointsJSON)) {
-        return mapToRealEntrypoints(entrypointsJSON, dir, { destDir: dest.destination });
+        return mapToRealEntrypoints(entrypointsJSON, dir, supportedExtensions, { destDir: dest.destination });
     }
     else {
         return Object.entries(entrypointsJSON).map(([name, config]) => {
@@ -115,31 +114,95 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
             if (!dirent.isDirectory()) {
                 continue;
             }
-            //TODO: Instead of doing all of this in a precalc phase, add block.json "entrypoints" with their library type set to "block-json"
+            //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 = [];
                 const wpmlFiles = [];
                 try {
-                    const blockJSON = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dir, 'block.json'), 'utf8'));
-                    const blockJSONChunkName = node_path_1.default.join(dest.destination, node_path_1.default.relative(srcRoot, dir), "block.json");
-                    for (const key of entrypointFields) {
-                        if (key in blockJSON) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(blockJSON[key], dir, { mapper: ep => ep.startsWith("file:") ? ep.substring(5) : ep, lazyDependent: blockJSONChunkName, destDir: dest.destination }));
+                    const blockJsonOrigin = node_path_1.default.join(dir, 'block.json');
+                    const blockJson = JSON.parse(await promises_1.default.readFile(blockJsonOrigin, 'utf8'));
+                    const blockJsonChunkName = node_path_1.default.join(dest.destination, node_path_1.default.relative(srcRoot, dir), "block");
+                    const presentEntrypoints = (await Promise.all(entrypointFields
+                        .filter(entrypointField => entrypointField in blockJson)
+                        .flatMap(entrypointField => {
+                        return (Array.isArray(blockJson[entrypointField]) ? blockJson[entrypointField] : [blockJson[entrypointField]])
+                            .filter(originalValue => originalValue.startsWith("file:"))
+                            .map(originalValue => {
+                            const entrypointPath = originalValue.substring(5);
+                            const absoluteSrc = node_path_1.default.normalize(node_path_1.default.join(dir, entrypointPath));
+                            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 };
+                                }
+                                else {
+                                    return undefined;
+                                }
+                            }, () => undefined);
+                        });
+                    }))).filter(pe => pe !== undefined);
+                    const entrypointNamesWithEffectiveDuplicates = presentEntrypoints
+                        .map(entry => entry.entrypointName)
+                        .reduce((a, dest) => {
+                        // If it's undefined, then this is the first instance, otherwise, it's not the first instance and, therefore, is expected to be a duplicate
+                        a[dest] = (a[dest] !== undefined);
+                        return a;
+                    }, {});
+                    const handlePrefix = blockJson['name']?.toString() ?? `__UNKNOWN_PREFIX__/${dirent.name}`;
+                    const allocatedDestinations = {};
+                    const resolvedBlockEntrypoints = presentEntrypoints
+                        .map(presentEntrypoint => {
+                        const overallSource = node_path_1.default.dirname(blockJsonOrigin);
+                        const overallSourceRelativeName = node_path_1.default.relative(overallSource, node_path_1.default.normalize(node_path_1.default.join(blockJsonOrigin, node_path_1.default.relative(overallSource, presentEntrypoint.extensionlessExpectedSrc))));
+                        if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
+                            return { blockJsonOrigin, ...presentEntrypoint, handle: `${handlePrefix}/${overallSourceRelativeName}` };
                         }
-                    }
+                        const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
+                        let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
+                        while (((deduplicatedEntrypointName = (presentEntrypoint.entrypointName + suffix)) in allocatedDestinations)
+                            && allocatedDestinations[deduplicatedEntrypointName] !== presentEntrypoint.originalValue) {
+                            suffix = baseSuffix + "_" + (++count);
+                        }
+                        allocatedDestinations[deduplicatedEntrypointName] = presentEntrypoint.originalValue;
+                        const deduplicatedExtensionlessExpectedSrc = presentEntrypoint.extensionlessExpectedSrc + suffix;
+                        return {
+                            blockJsonOrigin,
+                            ...presentEntrypoint,
+                            entrypointName: deduplicatedEntrypointName,
+                            extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
+                            handle: `${handlePrefix}/${count ? overallSourceRelativeName + "_" + count : overallSourceRelativeName}`
+                        };
+                    });
+                    rawEntrypoints.push(...resolvedBlockEntrypoints
+                        .map(resolvedBlockEntrypoint => {
+                        return [
+                            resolvedBlockEntrypoint.entrypointName,
+                            {
+                                import: resolvedBlockEntrypoint.absoluteSrc,
+                                library: { name: (0, shared_1.packBlockEntrypointInfoForSmuggling)(resolvedBlockEntrypoint), type: `block-json-${dest.destination}` }
+                            }
+                        ];
+                    }));
+                    rawEntrypoints.push([blockJsonChunkName, { import: blockJsonOrigin, library: { name: "block-json-inclusion-assurance", type: `block-json-${dest.destination}` } }]);
                     wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
-                    BlockJSONManagingPlugin_1.BlockJSONManagingPlugin.recordBlockJSONAssetSourceDir(blockJSONChunkName, dir);
                 }
                 catch (e) {
                     try {
                         const packageJSON = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dir, 'package.json'), 'utf8'));
-                        rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['main'], dir, { destDir: dest.destination }));
-                        rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['style'], dir, { destDir: dest.destination }));
+                        if (packageJSON['main']) {
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['main'], dir, commonConfig.scriptExtension.test, { destDir: dest.destination }));
+                        }
+                        if (!processingModules && packageJSON['style']) {
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['style'], dir, shared_1.styleExtension.test, { destDir: dest.destination }));
+                        }
                     }
                     catch (e) {
                         try {
-                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest));
+                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || shared_1.styleExtension.test(ep)));
                         }
                         catch (e) {
                             // This just means that the directory doesn't contain any declared entrypoints.
@@ -173,22 +236,16 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                 }
             }
         }
-        // This is used to allow for block.json dependencies to correctly account for name-deduplication
-        for (const [key, entry] of Object.entries(currentEntry)) {
-            if (typeof entry === 'object' && !Array.isArray(entry) && 'lazyDependent' in entry && typeof entry.lazyDependent === 'string') {
-                BlockJSONManagingPlugin_1.BlockJSONManagingPlugin.recordRawDependency(entry.lazyDependent, key);
-            }
-        }
         if (!processingModules) {
             const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
             try {
                 await promises_1.default.access(node_path_1.default.join(srcRoot, "wpml-config.xml"));
-                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles] };
+                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], library: { type: `block-json-${dest.destination}` } };
             }
             catch (e) {
                 // If the wpml-config.xml file does not exist, just "import" the other files that will be used to build the emitted version
                 if (wpmlEntrypointFiles.length) {
-                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles };
+                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles, library: { type: `block-json-${dest.destination}` } };
                 }
             }
         }
@@ -260,7 +317,7 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
             .map(plugin => !processingModules && plugin.constructor.name === 'CopyPlugin'
             ? new copy_webpack_plugin_1.default({
                 patterns: [{
-                        from: standaloneBlocks ? '**/(block.json|*.(php|twig|svg))' : '**/(block.json|*.(asset\.php|svg))',
+                        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
                     }]

package/build/utils/php-writer.d.ts

@@ -4,6 +4,8 @@ export declare class Expr {
     private readonly raw;
     static readonly jsonToPHPConverter: (obj: unknown, parentIndent?: string) => string;
     static readonly convertJsonToPHP: (obj: unknown) => string;
+    static readonly __FILE__: Expr;
+    static readonly __DIR__: Expr;
     constructor(value: string, raw?: boolean);
     toString(): string;
 }

package/build/utils/php-writer.js

@@ -11,6 +11,8 @@ class Expr {
     raw;
     static jsonToPHPConverter = json_to_php_but_with____injection_1.default.make({ shortArraySyntax: true });
     static convertJsonToPHP = (obj) => obj instanceof Expr ? obj.toString() : Expr.jsonToPHPConverter(obj);
+    static __FILE__ = new Expr("__FILE__");
+    static __DIR__ = new Expr("__DIR__");
     constructor(value, raw = true) {
         this.value = value;
         this.raw = raw;
@@ -281,7 +283,7 @@ class PHPWriter {
         for (const scopeItem of scope) {
             this.allocatedGeneratedFunctionNames.delete(scopeItem);
         }
-        return this.call("unset", scope.map(v => new Expr(v)));
+        return this.append(`unset(${scope.join(", ")});`); // This is equivalent to calling this.call("unset", scope.map(v => new Expr(v))), but creates fewer objects
     }
     /**
      * Pops the top scope from the stack WITHOUT calling unset for the variables that were assigned within it.

package/build/wordpress-scripts-wrapper.js

@@ -8,12 +8,12 @@ const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("./shared");
 const common_config_helpers_1 = require("./utils/common-config-helpers");
 const AdditionalDependencyInjectorPlugin_1 = require("./plugins/AdditionalDependencyInjectorPlugin");
-const BlockJSONManagingPlugin_1 = require("./plugins/BlockJSONManagingPlugin");
 const BrowserSyncPlugin_1 = require("./plugins/BrowserSyncPlugin");
 const ExtensionsConfigFileGeneratorPlugin_1 = require("./plugins/ExtensionsConfigFileGeneratorPlugin");
 const MiniCSSExtractPluginErrorCleaner_1 = require("./plugins/MiniCSSExtractPluginErrorCleaner");
 const PackageConfigSanityChecker_1 = require("./plugins/PackageConfigSanityChecker");
 const PlainEntrypointsConfigFileGeneratorPlugin_1 = require("./plugins/PlainEntrypointsConfigFileGeneratorPlugin");
+const PlainEntrypointsStyleBlockJSONPlugin_1 = require("./plugins/PlainEntrypointsStyleBlockJSONPlugin");
 const SpecialAssetHandlingPlugin_1 = require("./plugins/SpecialAssetHandlingPlugin");
 const VariablesJSMonitorPlugin_1 = require("./plugins/VariablesJSMonitorPlugin");
 const WPMLConfigBuilder_1 = require("./plugins/WPMLConfigBuilder");
@@ -377,7 +377,8 @@ function buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest,
     handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins);
     const removeEmptyScriptsPlugin = new webpack_remove_empty_scripts_1.default({
         stage: webpack_remove_empty_scripts_1.default.STAGE_AFTER_PROCESS_PLUGINS,
-        extensions: ['css', 'scss', 'sass', 'less', 'styl', 'pcss']
+        extensions: ['css', 'scss', 'sass', 'less', 'styl', 'pcss'],
+        ignore: /block\.json/
     });
     plugins.push(removeEmptyScriptsPlugin, new MiniCSSExtractPluginErrorCleaner_1.MiniCSSExtractPluginErrorCleaner());
     plugins.push(new UnifiedLoaderGenerator_1.UnifiedLoaderGenerator(config));
@@ -390,7 +391,7 @@ function buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest,
     else {
         const localAssumeGlobalizedPlauditLibraries = dest.assumeGlobalizedPlauditLibraries ?? assumeGlobalizedPlauditLibraries;
         const wantsGroupedDepData = combineAssetMetadata
-            && ((!processingModules && sourceType === "blocks" /* SourceType.blocks */)
+            && ((sourceType === "blocks" /* SourceType.blocks */)
                 || (extensionsVersion > 1 && sourceType === "extensions" /* SourceType.extensions */)
                 || (plainEntrypointsVersion > 1 && sourceType === "plain" /* SourceType.plain */));
         const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(externals, localAssumeGlobalizedPlauditLibraries, wantsGroupedDepData, dest.externalize);
@@ -430,6 +431,17 @@ function commonConfigProcessingPrep(config, webpackConfig) {
             }
         });
     }
+    fixedRules.push({
+        test: /block\.json$/i,
+        resourceQuery: /for-resource-tracking/i,
+        type: 'asset/resource',
+        generator: {
+            binary: false,
+            filename(pathData) {
+                return `${node_path_1.default.dirname(pathData.runtime)}/block[ext]`;
+            }
+        }
+    });
     return {
         entrypointFields, fixedRules, processingModules, scriptExtension,
         updateCurrentVariables: (value) => currentVariables = value
@@ -465,7 +477,6 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
             }
             case "plain" /* SourceType.plain */:
                 if (!srcIsDirectory) {
-                    //TODO: We need to filter this when in directory mode as well
                     const primarySrcRoot = typeof srcRoot === 'string' ? srcRoot : srcRoot[0];
                     if (!scriptExtension.test(primarySrcRoot) && !shared_1.styleExtension.test(primarySrcRoot)) {
                         return undefined;
@@ -481,10 +492,10 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
 }
 function makeBlocksWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
     const { processingModules } = commonConfig;
-    const blockJSONManagingPlugin = new BlockJSONManagingPlugin_1.BlockJSONManagingPlugin(config.standaloneBlocks, processingModules, dest.destination);
+    const blockJSONManagingPlugin = new PlainEntrypointsStyleBlockJSONPlugin_1.PlainEntrypointsStyleBlockJSONPlugin(config, dest.destination, plugins.find(p => p instanceof webpack_remove_empty_scripts_1.default));
     plugins.push(blockJSONManagingPlugin);
     if (config.processTranslationConfigs && !processingModules) {
-        plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(blockJSONManagingPlugin, dest.destination));
+        plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(dest.destination));
     }
     return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest), plugins);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.61.1",
+  "version": "2.62.0",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"

package/build/plugins/BlockJSONManagingPlugin.d.ts

@@ -1,40 +0,0 @@
-import { Compilation, type Compiler, type WebpackPluginInstance } from "webpack";
-export declare class BlockJSONManagingPlugin implements WebpackPluginInstance {
-    private readonly standaloneBlocks;
-    private readonly processingModules;
-    private readonly blocksDest;
-    static readonly mappableModuleKeys: readonly ["viewScriptModule", "scriptModule"];
-    static readonly mappableNonModuleKeys: readonly ["editorScript", "script", "viewScript", "editorStyle", "style", "viewStyle"];
-    private static readonly mappableKeys;
-    private static readonly blockJsonToEntrypointsMap;
-    private static readonly blockJsonRawDependenciesMap;
-    private static readonly blockJSONAssetSourceDirs;
-    private static readonly blockJsonAssetKeyMapping;
-    private static readonly syncsManager;
-    readonly additionalMetadata: Map<string, any>;
-    private readonly id;
-    constructor(standaloneBlocks: boolean, processingModules: boolean | undefined, blocksDest: string);
-    static recordRawDependency(entrypoint: string, dependency: string): void;
-    static recordBlockJSONAssetSourceDir(entrypoint: string, source: string): void;
-    apply(compiler: Compiler): void;
-    static resolveDestinationBySourceExtension(srcPath: string, entrypoint: Compilation['asyncEntrypoints'][number]): string | undefined;
-    static findCommonAncestor(...paths: string[]): string[];
-    static findRelativeRouteBetween(path1: string, path2: string): string;
-    private static remapReferencedPHPFilesOnKey;
-    private static hashThingForAsset;
-    private static stripFilePrefix;
-    private static buildFakeCompilationAssets;
-    private static incorporateRemappedAsset;
-    private static remapReferencedAssetFile;
-    private static getReferencedFileSlot;
-    private static addAssetToBlockJsonKey;
-    private registerAssetProcessor;
-    private static populateEntrypointsMap;
-    private registerBlockJsonProcessor;
-    private static normalizeRenderTemplate;
-    private getAssetDetails;
-    private static getAssetDataAccountingForCSS;
-    private static findFirstChunkFileWithExtension;
-    private static getChunkFilesByRuntimeName;
-    private stripBlocksDest;
-}