@plaudit/webpack-extensions 2.58.0 → 2.58.1

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -60,14 +60,14 @@ class ExtensionsConfigFileGeneratorPlugin {
                             }
                             writer
                                 .use("Plaudit\\Base\\API\\ThemeUtils")
+                                .withScope(writer => writer
                                 .assign("$filePathPrefix", new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest)}`))
                                 .call("plaudit_webpack_extensions__resolve_base_uri", [new php_writer_1.Expr("$filePathPrefix")], { assignTo: "$fileUriPrefix" })
                                 .call("ThemeUtils::loadExtensionsV2", [
                                 new php_writer_1.Expr(`__DIR__.${php_writer_1.Expr.convertJsonToPHP(finalExtensionsDest + "mapping.config.php")}`),
                                 new php_writer_1.Expr(`$filePathPrefix`), new php_writer_1.Expr("$fileUriPrefix"),
                                 `${this.handlePrefix ? this.handlePrefix : node_path_1.default.basename(process.cwd())}_extension_`
-                            ])
-                                .call("unset", [new php_writer_1.Expr("$filePathPrefix"), new php_writer_1.Expr("$fileUriPrefix")]);
+                            ]));
                         }]);
                 });
                 compilation.hooks.processAssets.tapPromise(tapName, async (assets) => {

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

@@ -24,11 +24,13 @@ export declare class PHPWriter {
     private printingInPHP;
     private fileNamespace;
     private useList;
+    private scopeStack;
     constructor(inlineFirstLine?: boolean);
     indent(): this;
     outdent(): this;
     append(...lines: (string | Expr)[]): this;
     assign(variable: string | string[], expression: unknown | Expr, opts?: {
+        chain?: boolean;
         return?: boolean;
     }): this;
     return(line: string | Expr): this;
@@ -39,7 +41,7 @@ export declare class PHPWriter {
     linebreak(): this;
     call(func: string, args: unknown[], opts?: {
         chain?: boolean;
-        assignTo?: string;
+        assignTo?: string | string[];
         return?: boolean;
     }): this;
     action(name: string | Expr, contents: (writer: this) => void, args?: ActionOrFilterArgs): this;
@@ -54,6 +56,24 @@ export declare class PHPWriter {
     openPHP(): this;
     namespace(namespace: string): this;
     use(...uses: string[]): this;
+    /**
+     * Starts a scope that, when paired with {@link #closeScope()}, allows for automating unset calls.
+     * All scopes started MUST be paired with either an {@link #closeScope()} or {@link #popScope()} call.
+     */
+    openScope(): this;
+    /**
+     * Pops the top scope from the stack AND unsets all variables that were assigned within it
+     */
+    closeScope(): this;
+    /**
+     * Pops the top scope from the stack WITHOUT calling unset for the variables that were assigned within it.
+     * This is used to allow function bodies to be safely created without disrupting their containing scope.
+     */
+    popScope(): this;
+    withScope(code: (writer: this) => void, opts?: {
+        actionDescription?: string;
+        usePopScopeInstead?: boolean;
+    }): this;
     toString(): string;
     emitAsset(compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
 }

package/build/utils/php-writer.js

@@ -27,6 +27,7 @@ class PHPWriter {
     printingInPHP = true;
     fileNamespace = "";
     useList = [];
+    scopeStack = [];
     constructor(inlineFirstLine = false) {
         this.inlineFirstLine = inlineFirstLine;
     }
@@ -45,12 +46,24 @@ class PHPWriter {
         return this;
     }
     assign(variable, expression, opts = {}) {
-        const lineComponents = (typeof variable === 'string' ? [variable] : variable).map(v => `${v} =`);
+        let lineComponents;
+        if (typeof variable === 'string') {
+            if (this.scopeStack.length > 0) {
+                this.scopeStack[this.scopeStack.length - 1].push(variable);
+            }
+            lineComponents = [`${variable} =`];
+        }
+        else {
+            if (this.scopeStack.length > 0) {
+                this.scopeStack[this.scopeStack.length - 1].push(...variable);
+            }
+            lineComponents = variable.map(v => `${v} =`);
+        }
         if (opts.return) {
             lineComponents.splice(0, 0, "return");
         }
         lineComponents.push(Expr.convertJsonToPHP(expression));
-        return this.append(lineComponents.join(" ") + ';');
+        return this.append(!opts.chain ? lineComponents.join(" ") + ';' : lineComponents.join(" "));
     }
     return(line) {
         return this.append(`return ${line};`);
@@ -72,15 +85,16 @@ class PHPWriter {
         return this;
     }
     call(func, args, opts = {}) {
+        const functionCall = `${func}(${args.map(Expr.convertJsonToPHP).join(", ")})`;
+        if (opts.assignTo) {
+            return this.assign(opts.assignTo, new Expr(functionCall), opts);
+        }
         const lineComponents = [];
         if (opts.return) {
             lineComponents.push("return");
         }
-        if (opts.assignTo) {
-            lineComponents.push(`${opts.assignTo} =`);
-        }
-        lineComponents.push(`${func}(${args.map(Expr.convertJsonToPHP).join(", ")})${opts.chain === true ? "" : ";"}`);
-        return this.append(lineComponents.join(" "));
+        lineComponents.push(functionCall);
+        return this.append(!opts.chain ? lineComponents.join(" ") + ';' : lineComponents.join(" "));
     }
     action(name, contents, args = {}) {
         return this.actionOrFilter('action', name, contents, args);
@@ -98,7 +112,9 @@ class PHPWriter {
         declarationComponents.push("{");
         this.openPHP().append(`add_${type}(${declarationComponents.join(" ")}`);
         this.indent();
-        contents(this);
+        // We start a new scope here just in case this was called within an existing scope
+        // We pop the scope instead of closing it because we don't actually want to unset any variables that were created within the function
+        this.withScope(contents, { actionDescription: `closing the function call for the ${name} ${type}.`, usePopScopeInstead: true });
         this.openPHP().outdent();
         const actionOrFilterArgs = ["}"];
         const accepted_args = Math.max(functionArgParameters.length, 1); // This avoids us unnecessarily setting the accepted_args value to 0 for actions
@@ -150,7 +166,9 @@ class PHPWriter {
         declarationComponents.push("{");
         this.append(declarationComponents.join(' '));
         this.indent();
-        body(this);
+        // We start a new scope here just in case this was called within an existing scope
+        // We pop the scope instead of closing it because we don't actually want to unset any variables that were created within the function
+        this.withScope(body, { actionDescription: `closing the "${name}" function`, usePopScopeInstead: true });
         this.openPHP().outdent().append("}");
         if (args.includeExistenceCheck) {
             return this.endIf();
@@ -183,7 +201,48 @@ class PHPWriter {
         }
         return this;
     }
+    /**
+     * Starts a scope that, when paired with {@link #closeScope()}, allows for automating unset calls.
+     * All scopes started MUST be paired with either an {@link #closeScope()} or {@link #popScope()} call.
+     */
+    openScope() {
+        this.scopeStack.push([]);
+        return this;
+    }
+    /**
+     * Pops the top scope from the stack AND unsets all variables that were assigned within it
+     */
+    closeScope() {
+        const scope = this.scopeStack.pop();
+        return scope?.length ? this.call("unset", scope.map(v => new Expr(v))) : this;
+    }
+    /**
+     * Pops the top scope from the stack WITHOUT calling unset for the variables that were assigned within it.
+     * This is used to allow function bodies to be safely created without disrupting their containing scope.
+     */
+    popScope() {
+        this.scopeStack.pop();
+        return this;
+    }
+    withScope(code, opts = {}) {
+        const expectedScopeCount = this.scopeStack.length;
+        this.openScope();
+        code(this);
+        if (opts.usePopScopeInstead) {
+            this.popScope();
+        }
+        else {
+            this.closeScope();
+        }
+        if (expectedScopeCount !== this.scopeStack.length) {
+            console.trace(`Encountered an unexpected number of scopes (saw: ${this.scopeStack.length}, expected: ${expectedScopeCount})`, `while ${opts.actionDescription ?? "ending an encapsulating scope"}.`);
+        }
+        return this;
+    }
     toString() {
+        if (this.scopeStack.length) {
+            console.trace("toString() was called on a PHPWriter that has a dangling scope");
+        }
         const fileContents = [];
         let canInline = true;
         if (this.fileNamespace) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.58.0",
+  "version": "2.58.1",
   "license": "UNLICENSED",
   "files": [
     "/build"
@@ -63,7 +63,7 @@
     "postcss-url": "^10.1.3",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "webpack": "^5.101.1",
+    "webpack": "^5.101.2",
     "webpack-remove-empty-scripts": "^1.1.1",
     "xml-formatter": "^3.6.6"
   },