@plaudit/webpack-extensions 2.62.1 → 2.62.3

package/build/plugins/AbstractMultiPhaseLibraryPlugin.d.ts

@@ -11,4 +11,10 @@ export declare abstract class AbstractMultiPhaseLibraryPlugin implements Webpack
     apply(compiler: Compiler): void;
     protected resetSemaphores(): void;
     protected abstract attachSecondPhase(compilation: Compilation): void;
+    protected getRelevantEntrypoints(compilation: Compilation): {
+        entrypoint: import("webpack").Entrypoint;
+        entrypointChunk: import("webpack").Chunk;
+        entrypointLibrary: import("webpack").LibraryOptions;
+        srcPath: string;
+    }[];
 }

package/build/plugins/AbstractMultiPhaseLibraryPlugin.js

@@ -84,5 +84,22 @@ class AbstractMultiPhaseLibraryPlugin {
             semaphore.reset(this.id);
         }
     }
+    getRelevantEntrypoints(compilation) {
+        return compilation.entrypoints.values()
+            .map(entrypoint => {
+            const entrypointChunk = entrypoint.getEntrypointChunk();
+            const entrypointLibrary = entrypointChunk.getEntryOptions()?.library;
+            if (entrypointLibrary?.type !== this.libraryType) {
+                return undefined;
+            }
+            const srcPath = entrypoint.origins[0]?.request;
+            if (!srcPath) {
+                return undefined;
+            }
+            return { entrypoint, entrypointChunk, entrypointLibrary, srcPath };
+        })
+            .filter(item => item !== undefined)
+            .toArray();
+    }
 }
 exports.AbstractMultiPhaseLibraryPlugin = AbstractMultiPhaseLibraryPlugin;

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -16,7 +16,7 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
     config;
     extensionsPath;
     extensionsDest;
-    static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ assets: [], setupFiles: [] }, "Extensions");
+    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]);
         this.config = config;
@@ -49,7 +49,9 @@ 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 = { assets: [], setupFiles: [] };
+                    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) {
@@ -68,7 +70,17 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
                         compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
                         return;
                     }
-                    myCacheData.assets.push(assetDataSource);
+                    const relevantAssetData = {};
+                    const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
+                    for (const { entrypointChunk, srcPath } of relevantEntrypoints) {
+                        const fileWithAssetData = entrypointChunk.files.values().find(file => assetDataSource[file]);
+                        if (!fileWithAssetData) {
+                            compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`assets.json did not contain information for ${srcPath}`, srcPath));
+                            continue;
+                        }
+                        relevantAssetData[fileWithAssetData] = assetDataSource[fileWithAssetData];
+                    }
+                    myCacheData.assets.push(relevantAssetData);
                     compilation.deleteAsset("assets.json");
                     ExtensionsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myCacheData);
                     UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.resolve(this.id, myCacheData.setupFiles.length > 0 || myCacheData.assets.length > 0 ? {
@@ -168,7 +180,7 @@ class ExtensionsConfigFileGeneratorPlugin extends AbstractMultiPhaseLibraryPlugi
                 main.assets.push(...assets);
                 main.setupFiles.push(...setupFiles);
                 return main;
-            }, { assets: [], setupFiles: [] });
+            }, { assets: [], setupFiles: [], libraryType: "" });
             if (combinedExtensionData.assets.length > 0 || combinedExtensionData.setupFiles.length > 0 || !this.config.useUnifiedLoader) {
                 this.generateVersionTwoConfigFile(compilation, combinedExtensionData);
             }

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.js

@@ -57,21 +57,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlug
                         .forEach(danglingBlockJsFile => {
                         compilation.deleteAsset(danglingBlockJsFile);
                     });
-                    const relevantEntrypoints = compilation.entrypoints.values()
-                        .map(entrypoint => {
-                        const entrypointChunk = entrypoint.getEntrypointChunk();
-                        const entrypointLibrary = entrypointChunk.getEntryOptions()?.library;
-                        if (entrypointLibrary?.type !== this.libraryType) {
-                            return undefined;
-                        }
-                        const srcPath = entrypoint.origins[0]?.request;
-                        if (!srcPath) {
-                            return undefined;
-                        }
-                        return { entrypoint, entrypointChunk, entrypointLibrary, srcPath };
-                    })
-                        .filter(item => item !== undefined)
-                        .toArray();
+                    const relevantEntrypoints = this.getRelevantEntrypoints(compilation);
                     const blockJsonOriginToOutputMapping = {};
                     for (const { entrypoint, entrypointChunk, entrypointLibrary, srcPath } of relevantEntrypoints) {
                         if (node_path_1.default.basename(srcPath).toLowerCase() !== "block.json" || entrypointLibrary.name !== "block-json-inclusion-assurance") {
@@ -130,7 +116,7 @@ class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlug
                                 applicableBlockJsonFiles[epBlockJson].workableBlockEntrypointsInfo.push(...workableBlockEntrypointsInfo);
                             }
                             else {
-                                applicableBlockJsonFiles[epBlockJson] = { sourcePath: workableBlockEntrypointsInfo[0]?.blockJsonOrigin, workableBlockEntrypointsInfo: workableBlockEntrypointsInfo };
+                                applicableBlockJsonFiles[epBlockJson] = { sourcePath: workableBlockEntrypointsInfo[0]?.blockJsonOrigin, workableBlockEntrypointsInfo };
                             }
                         }
                     }

package/build/utils/php-writer.js

@@ -207,18 +207,14 @@ class Assignment extends ParenthesesEnclosableExpression {
         this.value = value;
         this.push = push;
         this.assignees = Array.isArray(assignees) ? assignees : [assignees];
-        if (this.push) {
-            if (this.assignees.some(a => a instanceof Access && !a.endsWithPotentiallyWritableExpression())) {
-                throw new Error("Cannot write to an access chain that does not end with a writable access");
-            }
+        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");
         }
-        else {
+        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;

package/package.json

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