@plaudit/webpack-extensions 2.62.2 → 2.63.0

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

@@ -1,14 +1,15 @@
+import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
+import { VerifiedAdvancedOutputConfig } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
 import { Compilation, type Compiler } from "webpack";
-import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
 export declare class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugin {
     private readonly config;
     private readonly extensionsPath;
-    private readonly extensionsDest;
+    private readonly dest;
     private static readonly semaphore;
-    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsPath: string, extensionsDest: string);
+    private static readonly perLibraryTypeSetupFilePaths;
+    constructor(config: VerifiedPlauditWordpressWebpackConfig, extensionsPath: string, dest: VerifiedAdvancedOutputConfig);
     apply(compiler: Compiler): void;
     private generateVersionTwoConfigFile;
-    private stripExtensionsDest;
     protected attachSecondPhase(compilation: Compilation): void;
 }

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -6,22 +6,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtensionsConfigFileGeneratorPlugin = void 0;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
+const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const shared_1 = require("../shared");
 const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const webpack_1 = require("webpack");
-const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
 class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
     config;
     extensionsPath;
-    extensionsDest;
+    dest;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ libraryType: "", assets: [], setupFiles: [] }, "Extensions");
-    constructor(config, extensionsPath, extensionsDest) {
-        super(`extensions-v2-${extensionsDest}`, [ExtensionsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
+    static perLibraryTypeSetupFilePaths = {};
+    constructor(config, extensionsPath, dest) {
+        super(`extensions-v2-${dest.destination}`, [ExtensionsConfigFileGeneratorPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
         this.config = config;
         this.extensionsPath = extensionsPath;
-        this.extensionsDest = extensionsDest;
+        this.dest = dest;
     }
     apply(compiler) {
         super.apply(compiler);
@@ -30,16 +31,19 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
                 compilation.contextDependencies.add(this.extensionsPath);
             }
             const emissionPromises = [];
-            for (const setupFilePath of await promises_1.default.readdir(this.extensionsPath)) {
+            for await (const { name: setupFilePath } of await promises_1.default.opendir(this.extensionsPath, { encoding: 'utf-8' })) {
                 if (setupFilePath.endsWith("-setup.php")) {
                     const setupFileSourcePath = node_path_1.default.join(this.extensionsPath, setupFilePath);
                     compilation.fileDependencies.add(setupFileSourcePath);
                     emissionPromises.push(promises_1.default.readFile(setupFileSourcePath).then(contents => {
-                        return compilation.emitAsset(node_path_1.default.join(this.extensionsDest, setupFilePath), new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+                        compilation.emitAsset(node_path_1.default.join(this.dest.destination, setupFilePath), new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+                        const blockSlug = /^(.+?)-setup.php$/i.exec(setupFilePath)?.[1];
+                        return [blockSlug, setupFilePath];
                     }));
                 }
             }
-            await Promise.all(emissionPromises);
+            ExtensionsConfigFileGeneratorPlugin.perLibraryTypeSetupFilePaths[this.libraryType] = (await Promise.all(emissionPromises))
+                .filter((item) => item[0] !== undefined).sort((a, b) => a[0].localeCompare(b[0]));
         });
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
             compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE, additionalAssets: true }, async (assets) => {
@@ -49,15 +53,8 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
                 try {
                     //TODO: It should be possible to use EntryPoints to determine the "original" file
                     //TODO: There is no reason to not use basically the exact same logic to implement support for this in plain file contexts
-                    const myCacheData = { libraryType: this.libraryType, assets: [], setupFiles: [] };
-                    //TODO: Load up the -setup.php files as "entrypoints" in the same way that we're loading up block.json files
-                    // That way, we'll be able to distinguish which ones go where
-                    for (const asset of Object.keys(compilation.assets).map(asset => this.stripExtensionsDest(asset))) {
-                        const blockSlug = /^(.+?)-setup.php$/i.exec(asset)?.[1];
-                        if (blockSlug) {
-                            myCacheData.setupFiles.push([blockSlug, asset]);
-                        }
-                    }
+                    const myCacheData = { libraryType: this.libraryType, assets: [],
+                        setupFiles: ExtensionsConfigFileGeneratorPlugin.perLibraryTypeSetupFilePaths[this.libraryType] ?? [] };
                     const rawAssetDataSource = assets["assets.json"]?.source();
                     if (typeof rawAssetDataSource !== 'string') {
                         ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
@@ -87,22 +84,40 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
                         group: this.libraryType,
                         requiresBaseURI: true,
                         action: writer => {
-                            let finalExtensionsDest = this.extensionsDest.endsWith("/") ? this.extensionsDest : this.extensionsDest + "/";
-                            if (!finalExtensionsDest.startsWith("/")) {
-                                finalExtensionsDest = "/" + finalExtensionsDest;
+                            const generateLoader = (writer) => {
+                                let finalExtensionsDest = this.dest.destination.endsWith("/") ? this.dest.destination : this.dest.destination + "/";
+                                if (!finalExtensionsDest.startsWith("/")) {
+                                    finalExtensionsDest = "/" + finalExtensionsDest;
+                                }
+                                const filePathPrefixVar = new php_writer_1.Var("filePathPrefix");
+                                const fileUriPrefixVar = new php_writer_1.Var("fileUriPrefix");
+                                writer
+                                    .assign(filePathPrefixVar, new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest)}`))
+                                    .call("plaudit_webpack_extensions__resolve_base_uri", [filePathPrefixVar], { assignTo: fileUriPrefixVar })
+                                    .call("GutenbergUtils::loadExtensionsV2", [
+                                    new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest + "mapping.config.php")}`),
+                                    filePathPrefixVar, fileUriPrefixVar,
+                                    `${this.config.plainEntrypointsHandlePrefix || node_path_1.default.basename(process.cwd())}_extension_`
+                                ]);
+                            };
+                            writer.use("Plaudit\\Common\\Lib\\GutenbergUtils");
+                            const potentialHandle = this.dest.locations?.handle;
+                            if (potentialHandle) {
+                                if (typeof potentialHandle === 'string') {
+                                    try {
+                                        //TODO: Generate a function
+                                        writer.function(potentialHandle, [], generateLoader, { returnType: 'void' });
+                                        return;
+                                    }
+                                    catch (e) {
+                                        compilation.errors.push((0, shared_1.newWebpackErrorForFile)(["An error occurred while emitting a function for dynamically loading extensions", { cause: e }], this.extensionsPath));
+                                    }
+                                }
+                                else {
+                                    compilation.errors.push(new Error("The extensions directoryLayout's handle support is limited to static strings"));
+                                }
                             }
-                            const filePathPrefixVar = new php_writer_1.Var("filePathPrefix");
-                            const fileUriPrefixVar = new php_writer_1.Var("fileUriPrefix");
-                            writer
-                                .use("Plaudit\\Common\\Lib\\GutenbergUtils")
-                                .withScope(writer => writer
-                                .assign(filePathPrefixVar, new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest)}`))
-                                .call("plaudit_webpack_extensions__resolve_base_uri", [filePathPrefixVar], { assignTo: fileUriPrefixVar })
-                                .call("GutenbergUtils::loadExtensionsV2", [
-                                new php_writer_1.Literal(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest + "mapping.config.php")}`),
-                                filePathPrefixVar, fileUriPrefixVar,
-                                `${this.config.plainEntrypointsHandlePrefix || node_path_1.default.basename(process.cwd())}_extension_`
-                            ]));
+                            writer.withScope(generateLoader);
                         }
                     } : undefined);
                 }
@@ -126,8 +141,8 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
         for (const assetDataSource of combinedExtensionData.assets) {
             const normalizedAssetData = Object.entries(assetDataSource)
                 .map(entry => {
-                const assetPath = this.extensionsDest && entry[0].startsWith(this.extensionsDest + "/")
-                    ? entry[0].substring(this.extensionsDest.length + 1) : entry[0];
+                const assetPath = this.dest.destination && entry[0].startsWith(this.dest.destination + "/")
+                    ? entry[0].substring(this.dest.destination.length + 1) : entry[0];
                 return [assetPath, entry[1]];
             });
             for (const [assetPath, assetData] of normalizedAssetData) {
@@ -168,10 +183,7 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
             return [block[0], Object.fromEntries(Object.entries(block[1]).toSorted(([a], [b]) => a.localeCompare(b)))];
         })
             .toSorted(([a], [b]) => a.localeCompare(b)));
-        compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig, true)));
-    }
-    stripExtensionsDest(item) {
-        return this.extensionsDest && item.startsWith(this.extensionsDest + "/") ? item.substring(this.extensionsDest.length + 1 /* we also need to drop the "/" */) : item;
+        compilation.emitAsset(node_path_1.default.join(this.dest.destination, "mapping.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig, true)));
     }
     attachSecondPhase(compilation) {
         compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_GenerateConfigFile`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -84,7 +84,6 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibrar
                         }
                         myAssetHandles.push({
                             handles,
-                            usageLocations: this.usageLocations,
                             handlePrefix: this.handlePrefix
                         });
                     }
@@ -126,15 +125,15 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibrar
         const plainEntrypointsConfig = { scriptHandles: {}, script_moduleHandles: {}, styleHandles: {} };
         for (const { handles, handlePrefix } of assets) {
             for (const { src, rest, locations, type, handleName } of handles) {
+                const basename = node_path_1.default.basename(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                 let finalHandleName;
-                if (handleName) {
-                    finalHandleName = handleName;
+                if (typeof handleName === 'string') {
+                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, basename);
                 }
                 else {
-                    const basename = node_path_1.default.basename(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                     const baseFinalHandleName = `${handlePrefix}.${(0, shared_1.kebabCase)(basename)}`;
                     const handleNameMap = usedHandleNames[type];
-                    finalHandleName = baseFinalHandleName;
+                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, basename);
                     for (let count = 0; finalHandleName in handleNameMap && handleNameMap[finalHandleName] !== src;) {
                         finalHandleName = `${baseFinalHandleName}-${++count}`;
                     }

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.js

@@ -255,7 +255,6 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlug
         return blockJson;
     }
     stripOffBlocksDestPrefix(file) {
-        file = node_path_1.default.normalize(file);
         return this.blocksDest && file.startsWith(this.blocksDest + "/") ? file.substring(this.blocksDest.length + 1 /* we also need to drop the "/" */) : file;
     }
     static hashThingForAsset(thing) {

package/build/shared.d.ts

@@ -20,7 +20,7 @@ export type UsageLocations = {
     [K in StandardLocationNames]?: boolean | number;
 } & {
     register?: boolean | number;
-    handle?: string;
+    handle?: string | ((generatedHandle: string) => string);
     registerScriptArgs?: {
         strategy?: 'defer' | 'async';
         in_footer?: boolean;
@@ -47,9 +47,11 @@ export type AdvancedOutputConfig = {
     assumeGlobalizedPlauditLibraries?: boolean;
     externalize?: Required<Configuration>['output']['library'];
     bundleAnalyzer?: boolean;
-    locations?: UsageLocations | string;
+    locations?: UsageLocations | UsageLocations['handle'];
+};
+export type VerifiedAdvancedOutputConfig = Omit<AdvancedOutputConfig, 'destination' | 'locations'> & Required<Pick<AdvancedOutputConfig, 'destination'>> & {
+    locations: UsageLocations;
 };
-export type VerifiedAdvancedOutputConfig = Omit<AdvancedOutputConfig, 'destination'> & Required<Pick<AdvancedOutputConfig, 'destination'>>;
 export type PlauditWordpressWebpackConfig = {
     standaloneBlocks?: boolean;
     variables?: Record<string, any>;
@@ -87,8 +89,9 @@ export type UnpackedBlockEntrypointInfo = {
     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 unpackSmuggledBlockEntrypointInfo(library: EntryOptions['library'], allowedEndings?: string[] | false): UnpackedBlockEntrypointInfo | undefined;
+export declare function isSmuggledLibraryInfo(libraryName: NonNullable<EntryOptions['library']>['name'] | undefined, allowedEndings?: string[] | false): libraryName is SmuggledBlockEntrypointInfo;
+export declare function convertUsageLocationsHandleToEmittableHandle(handle: UsageLocations['handle'], generatedHandle: string): string;
 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]>;
@@ -108,7 +111,7 @@ export declare function arrayIsLength<T, N extends number>(arr: T[] | null | und
 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;
+export declare function newWebpackErrorForFile(error: string | ConstructorParameters<typeof WebpackError>, 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
  */

package/build/shared.js

@@ -9,6 +9,7 @@ exports.determineCurrentSourceType = determineCurrentSourceType;
 exports.packBlockEntrypointInfoForSmuggling = packBlockEntrypointInfoForSmuggling;
 exports.unpackSmuggledBlockEntrypointInfo = unpackSmuggledBlockEntrypointInfo;
 exports.isSmuggledLibraryInfo = isSmuggledLibraryInfo;
+exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
 exports.leadingSlashIt = leadingSlashIt;
@@ -59,18 +60,23 @@ function determineCurrentSourceType(dest, srcIsDirectory) {
 function packBlockEntrypointInfoForSmuggling(info) {
     return [info.blockJsonOrigin, info.entrypointField, info.originalValue, info.entrypointName, info.handle];
 }
-function unpackSmuggledBlockEntrypointInfo(library) {
+const defaultAllowedEndings = ["/block.json", "/entrypoints.json", "/package.json"];
+function unpackSmuggledBlockEntrypointInfo(library, allowedEndings) {
     const libraryName = library?.name;
-    if (!isSmuggledLibraryInfo(libraryName)) {
+    if (!isSmuggledLibraryInfo(libraryName, allowedEndings)) {
         return undefined;
     }
     return { blockJsonOrigin: libraryName[0], entrypointField: libraryName[1], originalValue: libraryName[2], entrypointName: libraryName[3], handle: libraryName[4] };
 }
-function isSmuggledLibraryInfo(libraryName) {
+function isSmuggledLibraryInfo(libraryName, allowedEndings = defaultAllowedEndings) {
     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]);
+    return (!allowedEndings || allowedEndings.some(s => libraryName[0].endsWith(s))) && exports.entrypointFields.includes(libraryName[1]);
+}
+function convertUsageLocationsHandleToEmittableHandle(handle, generatedHandle) {
+    const emittableHandle = typeof handle === 'string' ? handle : handle?.(generatedHandle) ?? generatedHandle;
+    return emittableHandle.replaceAll("{basename}", generatedHandle);
 }
 function makeEmittableConfigPHP(data, asFullFile, parentIndent = "") {
     const prettyPrintedMetadata = json_to_php_but_with____injection_1.default.make({ indent: "\t", linebreak: "\n", shortArraySyntax: true })(data, parentIndent)
@@ -125,7 +131,7 @@ function parseEnvFile(contents) {
     }));
 }
 function newWebpackErrorForFile(error, file) {
-    const res = new webpack_1.WebpackError(error);
+    const res = typeof error === 'string' ? new webpack_1.WebpackError(error) : new webpack_1.WebpackError(...error);
     res.hideStack = true;
     res.file = file;
     return res;

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

@@ -18,5 +18,5 @@ export type CommonConfigProcessingResult = {
 };
 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: VerifiedAdvancedOutputConfig): () => Promise<EntryObject>;
+export declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: VerifiedAdvancedOutputConfig, libraryType: string | undefined): () => Promise<EntryObject>;
 export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, srcIsDirectory: boolean, dest: VerifiedAdvancedOutputConfig, src: string, srcRoot: string | string[], entry: () => Promise<EntryObject> | EntryObject, plugins: CommonPluginConfig['plugins']): Configuration;

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

@@ -33,20 +33,29 @@ function groupEntrypointsByAssetFile(entrypoints, entrypointNameExtractor) {
     }
     return seenPaths;
 }
-function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args = {}) {
-    const { mapper = ep => ep, destDir } = args;
+function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
+    const { mapper = ep => ep, dest } = 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 => {
         const parsedEntrypoint = node_path_1.default.parse(ep);
-        return [joinPossiblyAbsolutePaths(destDir, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name), { import: ep }];
+        const fakeEntrypointInfo = {
+            blockJsonOrigin: args.entrypointJsonOrigin,
+            entrypointField: shared_1.styleExtension.test(ep) ? 'style' : shared_1.scriptWithModuleExtension.test(ep) ? 'scriptModule' : 'script',
+            originalValue: ep,
+            entrypointName: parsedEntrypoint.name,
+            handle: (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, parsedEntrypoint.name)
+        };
+        return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name),
+            { import: ep, library: args.libraryType ? { type: args.libraryType, name: (0, shared_1.packBlockEntrypointInfoForSmuggling)(fakeEntrypointInfo) } : undefined }];
     });
 }
-function parseEntrypointsJSON(dir, dest, supportedExtensions) {
-    const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'entrypoints.json'), 'utf8'));
+function parseEntrypointsJSON(dir, dest, supportedExtensions, args) {
+    const entrypointJsonOrigin = node_path_1.default.join(dir, 'entrypoints.json');
+    const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(entrypointJsonOrigin, 'utf8'));
     if (Array.isArray(entrypointsJSON)) {
-        return mapToRealEntrypoints(entrypointsJSON, dir, supportedExtensions, { destDir: dest.destination });
+        return mapToRealEntrypoints(entrypointsJSON, dir, supportedExtensions, { dest, entrypointJsonOrigin, ...args });
     }
     else {
         return Object.entries(entrypointsJSON).map(([name, config]) => {
@@ -106,7 +115,7 @@ function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts, s
     }
     entry[potentialKey] = entrypoint[1];
 }
-function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
+function resolveEntryFromDirectory(commonConfig, srcRoot, dest, libraryType) {
     const { entrypointFields, processingModules, scriptExtension } = commonConfig;
     return async () => {
         const loadingEntrypoints = [];
@@ -158,8 +167,12 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         .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))));
+                        const handleSuffix = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, overallSourceRelativeName);
                         if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
-                            return { blockJsonOrigin, ...presentEntrypoint, handle: `${handlePrefix}/${overallSourceRelativeName}` };
+                            return {
+                                blockJsonOrigin, ...presentEntrypoint,
+                                handle: `${handlePrefix}/${handleSuffix}`
+                            };
                         }
                         const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
                         let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
@@ -174,7 +187,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             ...presentEntrypoint,
                             entrypointName: deduplicatedEntrypointName,
                             extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: `${handlePrefix}/${count ? overallSourceRelativeName + "_" + count : overallSourceRelativeName}`
+                            handle: `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`
                         };
                     });
                     rawEntrypoints.push(...resolvedBlockEntrypoints
@@ -192,17 +205,18 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                 }
                 catch (e) {
                     try {
-                        const packageJSON = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dir, 'package.json'), 'utf8'));
-                        if (packageJSON['main']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['main'], dir, commonConfig.scriptExtension.test, { destDir: dest.destination }));
+                        const packageJsonOrigin = node_path_1.default.join(dir, 'package.json');
+                        const packageJson = JSON.parse(await promises_1.default.readFile(packageJsonOrigin, 'utf8'));
+                        if (packageJson['main']) {
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, commonConfig.scriptExtension.test, { dest, libraryType, entrypointJsonOrigin: packageJsonOrigin }));
                         }
-                        if (!processingModules && packageJSON['style']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['style'], dir, shared_1.styleExtension.test, { destDir: dest.destination }));
+                        if (!processingModules && packageJson['style']) {
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, shared_1.styleExtension.test, { dest, libraryType, entrypointJsonOrigin: packageJsonOrigin }));
                         }
                     }
                     catch (e) {
                         try {
-                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || shared_1.styleExtension.test(ep)));
+                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || shared_1.styleExtension.test(ep), { libraryType }));
                         }
                         catch (e) {
                             // This just means that the directory doesn't contain any declared entrypoints.

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

@@ -18,6 +18,11 @@ export interface PotentiallyWriteableExpression extends EnclosableExpression {
 export declare function isEnclosableExpression(a: unknown): a is EnclosableExpression;
 export declare function isPotentiallyWriteableExpression(a: unknown): a is PotentiallyWriteableExpression;
 export declare abstract class AbstractEnclosableExpression extends Expr implements EnclosableExpression {
+    static readonly closers: Readonly<{
+        "(": ")";
+        "[": "]";
+        "{": "}";
+    }>;
     abstract toEnclosedForm(): string;
     not(): Not;
 }
@@ -31,9 +36,10 @@ export declare class Literal extends Expr {
     readonly expression: string;
     constructor(expression: string);
     toString(): string;
-    static make(expression: string, enclosed: true): EnclosedLiteral;
-    static make(expression: string, enclosureOpen: string, encloserClose: string): EnclosableLiteral;
-    static make(expression: string, enclosed?: false | undefined): Literal;
+    static of(expression: string | PHPWriter, enclosed: true): EnclosedLiteral;
+    static of(expression: string | PHPWriter, enclosureOpen: keyof typeof AbstractEnclosableExpression.closers, encloserClose?: string): EnclosableLiteral;
+    static of(expression: string | PHPWriter, enclosureOpen: string, encloserClose: string): EnclosableLiteral;
+    static of(expression: string | PHPWriter, enclosed?: false | undefined): Literal;
     static name(expression: string): EnclosedLiteral;
 }
 export declare class EnclosedLiteral extends Literal implements EnclosableExpression {
@@ -97,6 +103,19 @@ export declare class Call extends EnclosedExpression implements PotentiallyWrite
     constructor(callee: string | EnclosableExpression, args: readonly unknown[]);
     toString(): string;
 }
+export declare class Parameter extends Expr {
+    readonly value: unknown;
+    readonly name?: string | undefined;
+    constructor(value: unknown, name?: string | undefined);
+    toString(): string;
+}
+export declare class FirstClassCallable extends ParenthesesEnclosableExpression {
+    readonly name: EnclosableExpression;
+    constructor(name: EnclosableExpression);
+    static from(literal: string): FirstClassCallable;
+    toString(): string;
+}
+export declare const validPHPLabel: RegExp;
 type Assignable = EnclosedExpression & PotentiallyWriteableExpression;
 export declare class Assignment extends ParenthesesEnclosableExpression {
     readonly value: unknown;
@@ -140,7 +159,18 @@ export declare class PHPWriter {
     indent(): this;
     outdent(): this;
     setIndentation(level: number): this;
+    /**
+     * @param lines These are treated as literal *regardless of their types*
+     */
     append(...lines: (string | Expr)[]): this;
+    /**
+     * @param expr This is treated as literal *regardless of its type*
+     * @param opts flags to add additional markup around the expression
+     */
+    appendExpr(expr: string | Expr, opts?: {
+        chain?: boolean;
+        return?: boolean;
+    }): this;
     assign(assignee: ConstructorParameters<typeof Assignment>[0] | string, expression: unknown, opts?: {
         chain?: boolean;
         return?: boolean;
@@ -151,6 +181,11 @@ export declare class PHPWriter {
         withTest?: boolean | 'chainable';
     }): this;
     linebreak(): this;
+    /**
+     * @param func This is treated as literal *regardless of its type*
+     * @param args
+     * @param opts
+     */
     call(func: string | EnclosableExpression, args: unknown[], opts?: {
         chain?: boolean;
         assignTo?: ConstructorParameters<typeof Assignment>[0];
@@ -195,11 +230,5 @@ export declare class PHPWriter {
         includeNamespaceAndUse?: boolean;
     }): string;
     emitAsset(compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
-    /**
-     * @param expr Unlike most other methods on this class, this is treated as literal *regardless of the argument's type*
-     * @param opts
-     * @private
-     */
-    private appendWithPossibleReturnAndChain;
 }
 export {};

package/build/utils/php-writer.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PHPWriter = exports.Constants = exports.Assignment = exports.Call = exports.ObjectAccess = exports.ArrayAccess = exports.Access = exports.Not = exports.Op = exports.Var = exports.EnclosableLiteral = exports.EnclosedLiteral = exports.Literal = exports.EnclosedExpression = exports.ParenthesesEnclosableExpression = exports.AbstractEnclosableExpression = exports.Expr = void 0;
+exports.PHPWriter = exports.Constants = exports.Assignment = exports.validPHPLabel = exports.FirstClassCallable = exports.Parameter = exports.Call = exports.ObjectAccess = exports.ArrayAccess = exports.Access = exports.Not = exports.Op = exports.Var = exports.EnclosableLiteral = exports.EnclosedLiteral = exports.Literal = exports.EnclosedExpression = exports.ParenthesesEnclosableExpression = exports.AbstractEnclosableExpression = exports.Expr = void 0;
 exports.isEnclosableExpression = isEnclosableExpression;
 exports.isPotentiallyWriteableExpression = isPotentiallyWriteableExpression;
 const json_to_php_but_with____injection_1 = __importDefault(require("./json-to-php-but-with-__-injection"));
@@ -30,6 +30,7 @@ function isPotentiallyWriteableExpression(a) {
     return isEnclosableExpression(a) && 'potentiallyWritable' in a && a.potentiallyWritable === true;
 }
 class AbstractEnclosableExpression extends Expr {
+    static closers = Object.freeze({ "(": ")", "[": "]", "{": "}" });
     not() {
         return new Not(this);
     }
@@ -56,9 +57,12 @@ class Literal extends Expr {
     toString() {
         return this.expression;
     }
-    static make(expression, enclosed = false, enclosureClose) {
+    static of(expression, enclosed = false, enclosureClose) {
+        if (expression instanceof PHPWriter) {
+            expression = expression.toString({ includeOpenPHP: false, includeNamespaceAndUse: false }).trim();
+        }
         if (typeof enclosed === 'string') {
-            return new EnclosableLiteral(expression, enclosed, enclosureClose ?? enclosed);
+            return new EnclosableLiteral(expression, enclosed, enclosureClose ?? AbstractEnclosableExpression.closers[enclosed] ?? enclosed);
         }
         if (enclosed) {
             return new EnclosedLiteral(expression);
@@ -198,6 +202,34 @@ class Call extends EnclosedExpression {
     }
 }
 exports.Call = Call;
+class Parameter extends Expr {
+    value;
+    name;
+    constructor(value, name) {
+        super();
+        this.value = value;
+        this.name = name;
+    }
+    toString() {
+        return this.name ? `${this.name}: ${Expr.convertJsonToPHP(this.value)}` : Expr.convertJsonToPHP(this.value);
+    }
+}
+exports.Parameter = Parameter;
+class FirstClassCallable extends ParenthesesEnclosableExpression {
+    name;
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+    static from(literal) {
+        return new FirstClassCallable(Literal.name(literal));
+    }
+    toString() {
+        return this.name.toEnclosedForm() + "(...)";
+    }
+}
+exports.FirstClassCallable = FirstClassCallable;
+exports.validPHPLabel = /^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$/; // This is from https://www.php.net/manual/en/functions.user-defined.php
 class Assignment extends ParenthesesEnclosableExpression {
     value;
     push;
@@ -210,14 +242,11 @@ class Assignment extends ParenthesesEnclosableExpression {
         if (this.assignees.some(a => a instanceof Access && !a.endsWithPotentiallyWritableExpression())) {
             throw new Error("Cannot assign a value to an access chain that does not end in a writable state");
         }
-        if (!this.push && this.assignees.some(a => a instanceof Access && a.endsWithCall())) {
+        if (!this.push && this.assignees.some(a => a instanceof Call || (a instanceof Access && a.endsWithCall()))) {
             throw new Error("Cannot assign a value to an access chain that ends in a function call unless that 'assignment' is a push");
         }
     }
     toString() {
-        //TODO: Validate that we're in push mode if assigning to a call
-        if (!this.push && this.assignees.some(a => a instanceof Call)) {
-        }
         const assignmentValue = isEnclosableExpression(this.value) ? this.value.toEnclosedForm() : Expr.convertJsonToPHP(this.value);
         if (this.push) {
             return this.assignees[0].toEnclosedForm() + "[] = " + assignmentValue;
@@ -268,12 +297,23 @@ class PHPWriter {
         this.indentation = "\t".repeat(level);
         return this;
     }
+    /**
+     * @param lines These are treated as literal *regardless of their types*
+     */
     append(...lines) {
         for (const line of lines) {
             this.buffer.push(`${this.indentation}${line}`);
         }
         return this;
     }
+    /**
+     * @param expr This is treated as literal *regardless of its type*
+     * @param opts flags to add additional markup around the expression
+     */
+    appendExpr(expr, opts = {}) {
+        const res = (opts.return ? "return " : "") + expr.toString();
+        return this.append(!opts.chain ? res + ';' : res);
+    }
     assign(assignee, expression, opts = {}) {
         if (typeof assignee === 'string') {
             assignee = new Var(assignee);
@@ -288,10 +328,10 @@ class PHPWriter {
                 this.scopeStack[this.scopeStack.length - 1].push(assignee.name);
             }
         }
-        return this.appendWithPossibleReturnAndChain(new Assignment(assignee, expression), opts);
+        return this.appendExpr(new Assignment(assignee, expression), opts);
     }
     return(expression) {
-        return this.append(`return ${Expr.convertJsonToPHP(expression)};`);
+        return this.appendExpr(Expr.convertJsonToPHP(expression), { return: true });
     }
     static(variable, opts = {}) {
         if (typeof variable === 'string') {
@@ -312,12 +352,17 @@ class PHPWriter {
         this.buffer.push("");
         return this;
     }
+    /**
+     * @param func This is treated as literal *regardless of its type*
+     * @param args
+     * @param opts
+     */
     call(func, args, opts = {}) {
         const functionCall = new Call(typeof func === 'string' ? Literal.name(func) : func, args);
         if (opts.assignTo) {
             return this.assign(opts.assignTo, functionCall, opts);
         }
-        return this.appendWithPossibleReturnAndChain(functionCall, opts);
+        return this.appendExpr(functionCall, opts);
     }
     action(name, contents, args = {}) {
         return this.actionOrFilter('action', name, contents, args);
@@ -328,7 +373,7 @@ class PHPWriter {
     actionOrFilter(type, name, contents, args) {
         const { priority = 10, functionArgParameters = [], useVars = [], accountForAlreadyDoing } = args;
         const functionWriter = this.createSubwriter();
-        let declarationFunctionText;
+        let declarationFunction;
         if (accountForAlreadyDoing) {
             if (functionArgParameters.length > 0 && accountForAlreadyDoing === true) {
                 console.trace(`The accountForAlreadyDoing flag must be set to a list of default parameters when applied to ${type}s that take arguments`);
@@ -336,35 +381,35 @@ class PHPWriter {
             this.openPHP().openScope();
             const functionName = functionWriter.function(true, functionArgParameters, contents, { useVars, scopeActionDescription: `closing the function call for the ${name} ${type}.`, assignToName: true });
             this.append(functionWriter.toString().trim());
-            declarationFunctionText = functionName + "(...)";
+            declarationFunction = new FirstClassCallable(functionName);
             this.if(Expr.call(`doing_${type}`, [name]))
                 .call(functionName, accountForAlreadyDoing === true ? [] : accountForAlreadyDoing);
         }
         else {
             functionWriter.function(false, functionArgParameters, contents, { useVars, scopeActionDescription: `closing the function call for the ${name} ${type}.` });
-            declarationFunctionText = functionWriter.toString().trim();
+            declarationFunction = Literal.of(functionWriter);
         }
         // The trailing comma inside the first item is necessary
-        const declarationComponents = [`${Expr.convertJsonToPHP(name)}`, declarationFunctionText];
+        const additionArgs = [name, declarationFunction];
         const accepted_args = Math.max(functionArgParameters.length, 1); // This avoids us unnecessarily setting the accepted_args value to 0 for actions
         if (priority !== 10) {
-            declarationComponents.push(priority.toString());
+            additionArgs.push(priority);
             if (accepted_args !== 1) {
-                declarationComponents.push(accepted_args.toString());
+                additionArgs.push(accepted_args);
             }
         }
         else if (accepted_args !== 1) {
-            declarationComponents.push(`accepted_args: ${accepted_args}`);
+            additionArgs.push(new Parameter(accepted_args, "accepted_args"));
         }
-        const line = `add_${type}(${declarationComponents.join(", ")});`;
+        const line = Expr.call(`add_${type}`, additionArgs);
         if (accountForAlreadyDoing) {
             return this
                 .else()
-                .append(line)
+                .appendExpr(line)
                 .endIf()
                 .closeScope();
         }
-        return this.openPHP().append(line);
+        return this.openPHP().appendExpr(line);
     }
     if(condition) {
         return this.openPHP().append(`if (${condition}) {`).indent();
@@ -387,6 +432,11 @@ class PHPWriter {
                 console.trace('Anonymous functions cannot be assigned to a name');
             }
         }
+        if (typeof name === 'string') {
+            if (!exports.validPHPLabel.test(name)) {
+                throw new Error(`'${name}' is not a valid function name. Please see https://www.php.net/manual/en/functions.user-defined.php for what constitutes one`);
+            }
+        }
         const returningString = name === true;
         if (name === true) {
             name = this.generateFunctionName(args.assignToName);
@@ -553,14 +603,5 @@ class PHPWriter {
         const contents = this.toString() + "\n";
         compilation[file in compilation.assets ? 'updateAsset' : 'emitAsset'](file, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents), ...assetInfo });
     }
-    /**
-     * @param expr Unlike most other methods on this class, this is treated as literal *regardless of the argument's type*
-     * @param opts
-     * @private
-     */
-    appendWithPossibleReturnAndChain(expr, opts) {
-        const res = (opts.return ? "return " : "") + expr.toString();
-        return this.append(!opts.chain ? res + ';' : res);
-    }
 }
 exports.PHPWriter = PHPWriter;

package/build/wordpress-scripts-wrapper.js

@@ -211,15 +211,17 @@ function buildVerifiedConfig(config) {
     const allocatedDestinations = {};
     const partiallyVerifiedSources = rawSources.map(rawSource => {
         const destination = rawSource[1].destination;
+        const locations = typeof rawSource[1].locations === 'string' || typeof rawSource[1].locations === 'function'
+            ? { handle: rawSource[1].locations } : rawSource[1].locations ?? {};
         if (destination !== undefined) {
             const effectiveDestination = toEffectiveWebpackDestination(destination);
             allocatedDestinations[effectiveDestination] = rawSource[0]; // We need to pre-populate the allocatedDestinations map with statically-declared destinations
-            return [rawSource[0], { ...rawSource[1], destination, effectiveDestination, staticallyDeclaredDestination: true }];
+            return [rawSource[0], { ...rawSource[1], locations, destination, effectiveDestination, staticallyDeclaredDestination: true }];
         }
         else {
             const naiveDestination = deriveNaiveDestinationFromUnverifiedSourceEntry(rawSource, srcPrefixes);
             const effectiveDestination = toEffectiveWebpackDestination(naiveDestination);
-            return [rawSource[0], { ...rawSource[1], destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false }];
+            return [rawSource[0], { ...rawSource[1], locations, destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false }];
         }
     });
     const dynamicEffectiveDestinationsWithExpectedNaiveDuplicates = partiallyVerifiedSources
@@ -487,11 +489,11 @@ function makeBlocksWebpackConfig(config, commonConfig, webpackConfig, dest, src,
     if (config.processTranslationConfigs && !processingModules) {
         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);
+    return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest, blockJSONManagingPlugin.libraryType), plugins);
 }
 function makeExtensionsWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
     const plugin = config.extensionsVersion > 1
-        ? new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest.destination)
+        ? new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest)
         : new ExtensionsConfigFileGeneratorPluginV1_1.ExtensionsConfigFileGeneratorPluginV1(dest.destination);
     plugins.push(plugin);
     const entry = async () => {
@@ -511,16 +513,16 @@ function makeExtensionsWebpackConfig(config, commonConfig, webpackConfig, dest,
 function makePlainV1WebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins, srcIsDirectory) {
     const baseDest = stripExtension(dest.destination);
     const entry = srcIsDirectory // This being true implies that srcRoot is not an array
-        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest)
+        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest, undefined)
         : () => ({ [baseDest]: srcRoot });
     return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, srcIsDirectory, dest, src, srcRoot, entry, plugins);
 }
 function makePlainV2WebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins, srcIsDirectory) {
-    const locations = typeof dest.locations === 'string' ? { handle: dest.locations } : dest.locations ?? {};
-    plugins.push(new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(process.cwd(), config.outputDir, locations, config.plainEntrypointsHandlePrefix, config.useUnifiedLoader));
+    const requester = new PlainEntrypointsConfigFileGeneratorPlugin_1.PlainEntrypointsConfigFileGeneratorPlugin(process.cwd(), config.outputDir, dest.locations, config.plainEntrypointsHandlePrefix, config.useUnifiedLoader);
+    plugins.push(requester);
     const baseDest = stripExtension(dest.destination);
     const entry = srcIsDirectory // This being true implies that srcRoot is not an array
-        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest)
+        ? (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest, requester.libraryType)
         : () => ({ [baseDest]: srcRoot });
     return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, srcIsDirectory, dest, src, srcRoot, entry, plugins);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.62.2",
+  "version": "2.63.0",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"
@@ -35,8 +35,8 @@
     "@plaudit/postcss-silent-extend": "^3.0.0",
     "@plaudit/postcss-strip-units": "^3.0.0",
     "@plaudit/postcss-variables": "^1.1.0",
-    "@wordpress/dependency-extraction-webpack-plugin": "^6.29.0",
-    "@wordpress/scripts": "^30.22.0",
+    "@wordpress/dependency-extraction-webpack-plugin": "^6.30.0",
+    "@wordpress/scripts": "^30.23.0",
     "autoprefixer": "^10.4.21",
     "browser-sync": "^3.0.4",
     "clean-webpack-plugin": "^4.0.0",