@plaudit/webpack-extensions 2.61.2 → 2.62.1

package/build/plugins/WPMLConfigBuilder.js

@@ -6,18 +6,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WPMLConfigBuilderPlugin = void 0;
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
+const shared_1 = require("../shared");
 const jsdom_1 = require("jsdom");
 const webpack_1 = require("webpack");
 const xml_formatter_1 = __importDefault(require("xml-formatter"));
 class WPMLConfigBuilderPlugin {
-    blockJSONManagingPlugin;
     destDir;
     static jsdomInstance;
     static domParser;
     static xmlSerializer;
     parsedDocumentsCache = new Map();
-    constructor(blockJSONManagingPlugin, destDir) {
-        this.blockJSONManagingPlugin = blockJSONManagingPlugin;
+    constructor(destDir) {
         this.destDir = destDir;
     }
     apply(compiler) {
@@ -52,7 +51,7 @@ class WPMLConfigBuilderPlugin {
                     for (const category of nonMergeableCategories) {
                         for (const [key, value] of Object.entries(wpmlConfig[category])) {
                             if (key in mergedConfig[category]) {
-                                compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the ${category} entry named, "${key}"`, file));
+                                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Already encountered a definition for the ${category} entry named, "${key}"`, file));
                             }
                             else {
                                 mergedConfig[category][key] = value;
@@ -69,7 +68,7 @@ class WPMLConfigBuilderPlugin {
                         }
                         catch (e) {
                             if (typeof e === 'string') {
-                                compilation.errors.push(newWebpackErrorForFile(e, file));
+                                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(e, file));
                             }
                             else {
                                 compilation.errors.push(e);
@@ -145,7 +144,6 @@ class WPMLConfigBuilderPlugin {
                 }
                 appendNamedElementsListToConfig("shortcodes", mergedConfig.shortcodes, config);
                 appendNamedElementsListToConfig("taxonomies", mergedConfig.taxonomies, config);
-                this.blockJSONManagingPlugin.additionalMetadata.set("wpml-config", true);
                 compilation[wpmlEmitPath in compilation.assets ? 'updateAsset' : 'emitAsset'](wpmlEmitPath, new webpack_1.sources.RawSource(WPMLConfigBuilderPlugin.prettyPrintXML(config)));
             });
         });
@@ -205,7 +203,7 @@ class WPMLConfigBuilderPlugin {
                         }
                         catch (e) {
                             if (typeof e === 'string') {
-                                compilation.errors.push(newWebpackErrorForFile(e, file));
+                                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(e, file));
                             }
                             else {
                                 compilation.errors.push(e);
@@ -225,12 +223,12 @@ class WPMLConfigBuilderPlugin {
                         const tag = child.getElementsByTagName("tag")[0];
                         const shortcodeName = tag?.textContent?.trim();
                         if (!shortcodeName) {
-                            compilation.errors.push(newWebpackErrorForFile(`A shortcode entry in a wpml-config.xml file is missing its tag name.`, file));
+                            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`A shortcode entry in a wpml-config.xml file is missing its tag name.`, file));
                             continue;
                         }
                         const existing = res.shortcodes[shortcodeName];
                         if (existing) {
-                            compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the shortcode entry named, "${shortcodeName}"`, file));
+                            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Already encountered a definition for the shortcode entry named, "${shortcodeName}"`, file));
                         }
                         else {
                             res.shortcodes[shortcodeName] = child;
@@ -241,7 +239,7 @@ class WPMLConfigBuilderPlugin {
                     importStandardTranslateOptionMap(element, file, "taxonomy", res.taxonomies, compilation);
                     break;
                 default:
-                    compilation.errors.push(newWebpackErrorForFile(`Unsupported element type in a wpml-config.xml file: ${element.nodeName}`, file));
+                    compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Unsupported element type in a wpml-config.xml file: ${element.nodeName}`, file));
                     break;
             }
         }
@@ -254,17 +252,17 @@ function importStandardTranslateOptionMap(element, file, type, actionMap, compil
     for (const child of element.children) {
         const field = child.textContent;
         if (!field) {
-            compilation.errors.push(newWebpackErrorForFile(`Encountered an empty ${type} entry in a wpml-config.xml file.`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Encountered an empty ${type} entry in a wpml-config.xml file.`, file));
             continue;
         }
         const translate = child.getAttribute("translate");
         if (!translate) {
-            compilation.errors.push(newWebpackErrorForFile(`The ${type} entry for ${field} is missing the translate attribute.`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`The ${type} entry for ${field} is missing the translate attribute.`, file));
             continue;
         }
         const existing = actionMap[field];
         if (existing) {
-            compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the ${type} entry named, "${field}"`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Already encountered a definition for the ${type} entry named, "${field}"`, file));
         }
         else {
             actionMap[field] = child;
@@ -275,17 +273,17 @@ function importStandardTranslateActionMap(element, file, type, actionMap, compil
     for (const child of element.children) {
         const field = child.textContent?.trim();
         if (!field) {
-            compilation.errors.push(newWebpackErrorForFile(`Encountered a empty ${type} entry without a name in a wpml-config.xml file.`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Encountered a empty ${type} entry without a name in a wpml-config.xml file.`, file));
             continue;
         }
         const action = child.getAttribute("action");
         if (!action) {
-            compilation.errors.push(newWebpackErrorForFile(`The ${type} entry for ${field} is missing an action.`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`The ${type} entry for ${field} is missing an action.`, file));
             continue;
         }
         const existing = actionMap[field];
         if (existing) {
-            compilation.errors.push(newWebpackErrorForFile(`Already encountered a definition for the ${type} entry named, "${field}"`, file));
+            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Already encountered a definition for the ${type} entry named, "${field}"`, file));
         }
         else {
             actionMap[field] = child;
@@ -433,12 +431,6 @@ function mergeGenericSettingsKeys(existing, novel) {
     }
     return { ...existing, ...novel, keys: mergeGenericSettingsKeyLists(existing.keys, novel.keys) };
 }
-function newWebpackErrorForFile(error, file) {
-    const res = new webpack_1.WebpackError(error);
-    res.hideStack = true;
-    res.file = file;
-    return res;
-}
 function writeGenericSettingsKeys(keys, parent, document) {
     parent.append(...keys.sort((a, b) => a.name.localeCompare(b.name)).map(key => {
         const element = document.createElement("key");

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,30 +72,45 @@ export type PlauditWordpressWebpackConfig = {
     srcPrefixes?: string[];
     useUnifiedLoader?: boolean;
 };
-export declare function makeEmittableConfigPHP(data: any): string;
-export type Sync<V> = {
-    sync: Promise<V>;
-    resolve(v: V): void;
-    reject(): void;
-    done: boolean;
-};
-type Readiness<V> = {
-    nonModule: Sync<V>;
-    module: Sync<V>;
+export type SmuggledBlockEntrypointInfo = [
+    string,
+    EntrypointFields[number],
+    string,
+    string,
+    string
+];
+export type UnpackedBlockEntrypointInfo = {
+    blockJsonOrigin: string;
+    entrypointField: EntrypointFields[number];
+    originalValue: string;
+    entrypointName: string;
+    handle: string;
 };
-export declare class SyncsManager<V> {
-    private readonly readinessMapping;
-    get(name: string): Readiness<V>;
-    private makeSync;
-}
+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 declare function leadingSlashIt(pathOrSomething: string): string;
 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.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,34 +56,37 @@ 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(", ")}]`)
-        + ";";
-}
-class SyncsManager {
-    readinessMapping = new Map();
-    get(name) {
-        const res = this.readinessMapping.get(name);
-        if (res) {
-            return res;
-        }
-        this.readinessMapping.set(name, { nonModule: this.makeSync(), module: this.makeSync() });
-        return this.readinessMapping.get(name);
+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;
     }
-    makeSync() {
-        const res = { done: false };
-        res.sync = new Promise((resolve, reject) => {
-            res.resolve = (v) => resolve(v);
-            res.reject = () => reject();
-        });
-        return res;
+    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);
 }
-exports.SyncsManager = SyncsManager;
 function leadingSlashIt(pathOrSomething) {
     return pathOrSomething.startsWith('/') ? pathOrSomething : ('/' + pathOrSomething);
 }
@@ -83,9 +97,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 +124,33 @@ 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) {
+    const dir = new php_writer_1.Var("dir");
+    const baseUris = new php_writer_1.Var("base_uris");
+    const assignmentTarget = new php_writer_1.ArrayAccess(baseUris, dir);
+    const path = new php_writer_1.Var("path");
+    writer.function("plaudit_webpack_extensions__resolve_base_uri", [dir], writer => {
+        writer
+            .static(baseUris, { initializer: [] })
+            .if(php_writer_1.Expr.isset(assignmentTarget))
+            .return(assignmentTarget)
+            .elseIf(php_writer_1.Expr.call("str_starts_with", [dir, php_writer_1.Constants.ABSPATH]))
+            .assign(path, php_writer_1.Expr.call("ltrim", [php_writer_1.Expr.call("substr", [dir, php_writer_1.Expr.call("strlen", [php_writer_1.Constants.ABSPATH])]), "/"]))
+            .elseIf(php_writer_1.Expr.call("str_starts_with", [dir, "/workspace/website"]))
+            .assign(path, php_writer_1.Expr.call("ltrim", [php_writer_1.Expr.call("substr", [dir, 18]), "/"]))
+            .else()
+            .call("error_log", ["UNABLE TO FIGURE OUT WHAT THE RELATIVE PATH TO THE BUILT FILES DIRECTORY SHOULD BE"])
+            .assign(path, "")
+            .endIf()
+            .call("trailingslashit", [php_writer_1.Expr.call("home_url", [path])], { return: true, assignTo: assignmentTarget });
+    }, { 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
                     }]