@plaudit/webpack-extensions 2.62.0 → 2.62.2

package/build/utils/php-writer.js

@@ -3,25 +3,235 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PHPWriter = exports.Expr = void 0;
+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.isEnclosableExpression = isEnclosableExpression;
+exports.isPotentiallyWriteableExpression = isPotentiallyWriteableExpression;
 const json_to_php_but_with____injection_1 = __importDefault(require("./json-to-php-but-with-__-injection"));
 const webpack_1 = require("webpack");
 class Expr {
-    value;
-    raw;
     static jsonToPHPConverter = json_to_php_but_with____injection_1.default.make({ shortArraySyntax: true });
     static convertJsonToPHP = (obj) => obj instanceof Expr ? obj.toString() : Expr.jsonToPHPConverter(obj);
-    static __FILE__ = new Expr("__FILE__");
-    static __DIR__ = new Expr("__DIR__");
-    constructor(value, raw = true) {
+    constructor() { }
+    typeName() {
+        return this.constructor.name;
+    }
+    static isset(...checks) {
+        return Expr.call("isset", checks);
+    }
+    static call(name, args) {
+        return new Call(Literal.name(name), args);
+    }
+}
+exports.Expr = Expr;
+function isEnclosableExpression(a) {
+    return a instanceof Expr && 'toEnclosedForm' in a && typeof a.toEnclosedForm === 'function';
+}
+function isPotentiallyWriteableExpression(a) {
+    return isEnclosableExpression(a) && 'potentiallyWritable' in a && a.potentiallyWritable === true;
+}
+class AbstractEnclosableExpression extends Expr {
+    not() {
+        return new Not(this);
+    }
+}
+exports.AbstractEnclosableExpression = AbstractEnclosableExpression;
+class ParenthesesEnclosableExpression extends AbstractEnclosableExpression {
+    toEnclosedForm() {
+        return "(" + this.toString() + ")";
+    }
+}
+exports.ParenthesesEnclosableExpression = ParenthesesEnclosableExpression;
+class EnclosedExpression extends AbstractEnclosableExpression {
+    toEnclosedForm() {
+        return this.toString();
+    }
+}
+exports.EnclosedExpression = EnclosedExpression;
+class Literal extends Expr {
+    expression;
+    constructor(expression) {
+        super();
+        this.expression = expression;
+    }
+    toString() {
+        return this.expression;
+    }
+    static make(expression, enclosed = false, enclosureClose) {
+        if (typeof enclosed === 'string') {
+            return new EnclosableLiteral(expression, enclosed, enclosureClose ?? enclosed);
+        }
+        if (enclosed) {
+            return new EnclosedLiteral(expression);
+        }
+        return new Literal(expression);
+    }
+    static name(expression) {
+        return new EnclosedLiteral(expression);
+    }
+}
+exports.Literal = Literal;
+class EnclosedLiteral extends Literal {
+    constructor(expression) {
+        super(expression);
+    }
+    toEnclosedForm() {
+        return this.toString();
+    }
+    not() {
+        return new Not(this);
+    }
+}
+exports.EnclosedLiteral = EnclosedLiteral;
+class EnclosableLiteral extends Literal {
+    enclosureOpen;
+    enclosureClose;
+    constructor(expression, enclosureOpen, enclosureClose) {
+        super(expression);
+        this.enclosureOpen = enclosureOpen;
+        this.enclosureClose = enclosureClose;
+    }
+    toEnclosedForm() {
+        return this.enclosureOpen + this.toString() + this.enclosureClose;
+    }
+    not() {
+        return new Not(this);
+    }
+}
+exports.EnclosableLiteral = EnclosableLiteral;
+class Var extends EnclosedExpression {
+    name;
+    potentiallyWritable = true;
+    constructor(name) {
+        super();
+        this.name = name;
+    }
+    toString() {
+        return "$" + this.name;
+    }
+}
+exports.Var = Var;
+class Op extends ParenthesesEnclosableExpression {
+    operator;
+    args;
+    constructor(operator, ...args) {
+        super();
+        this.operator = operator;
+        this.args = args;
+    }
+    toString() {
+        return this.args
+            .map(a => isEnclosableExpression(a) ? a.toEnclosedForm() : Expr.convertJsonToPHP(a))
+            .join(this.operator);
+    }
+    static binary(left, operator, right) {
+        return new Op(operator, left, right);
+    }
+    static join(...args) {
+        return new Op(".", ...args);
+    }
+}
+exports.Op = Op;
+class Not extends ParenthesesEnclosableExpression {
+    expression;
+    constructor(expression) {
+        super();
+        this.expression = expression;
+    }
+    toString() {
+        return "!" + this.expression.toEnclosedForm();
+    }
+}
+exports.Not = Not;
+class Access extends EnclosedExpression {
+    target;
+    potentiallyWritable = true;
+    accesses;
+    constructor(target, accesses) {
+        super();
+        this.target = target;
+        this.accesses = Array.isArray(accesses) ? accesses : [accesses];
+    }
+}
+exports.Access = Access;
+class ArrayAccess extends Access {
+    toString() {
+        return this.target.toEnclosedForm() + this.accesses.map(a => `[${Expr.convertJsonToPHP(a)}]`).join("");
+    }
+    endsWithCall() {
+        return false;
+    }
+    endsWithPotentiallyWritableExpression() {
+        return true;
+    }
+}
+exports.ArrayAccess = ArrayAccess;
+class ObjectAccess extends Access {
+    static validObjectKey = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
+    toString() {
+        return [this.target.toString(), ...this.accesses.map(a => {
+                if ((typeof a === 'string' && ObjectAccess.validObjectKey.test(a)) || a instanceof Var || a instanceof Call) {
+                    return a;
+                }
+                return "{" + Expr.convertJsonToPHP(a) + "}";
+            })].join("->");
+    }
+    endsWithCall() {
+        return this.accesses[this.accesses.length - 1] instanceof Call;
+    }
+    endsWithPotentiallyWritableExpression() {
+        return isPotentiallyWriteableExpression(this.accesses[this.accesses.length - 1]);
+    }
+}
+exports.ObjectAccess = ObjectAccess;
+class Call extends EnclosedExpression {
+    callee;
+    args;
+    potentiallyWritable = true;
+    constructor(callee, args) {
+        super();
+        this.callee = callee;
+        this.args = args;
+    }
+    toString() {
+        const callee = typeof this.callee === 'string' ? Expr.convertJsonToPHP(this.callee) : this.callee.toEnclosedForm();
+        return `${callee}(${this.args.map(Expr.convertJsonToPHP).join(", ")})`;
+    }
+}
+exports.Call = Call;
+class Assignment extends ParenthesesEnclosableExpression {
+    value;
+    push;
+    assignees;
+    constructor(assignees, value, push = false) {
+        super();
         this.value = value;
-        this.raw = raw;
+        this.push = push;
+        this.assignees = Array.isArray(assignees) ? assignees : [assignees];
+        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())) {
+            throw new Error("Cannot assign a value to an access chain that ends in a function call unless that 'assignment' is a push");
+        }
     }
     toString() {
-        return this.raw ? this.value : Expr.jsonToPHPConverter(this.value);
+        //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;
+        }
+        return [...this.assignees.map(t => t.toEnclosedForm()), assignmentValue].join(" = ");
     }
 }
-exports.Expr = Expr;
+exports.Assignment = Assignment;
+class Constants {
+    static __FILE__ = Literal.name("__FILE__");
+    static __DIR__ = Literal.name("__DIR__");
+    static ABSPATH = Literal.name("ABSPATH");
+}
+exports.Constants = Constants;
 class PHPWriter {
     inlineFirstLine;
     scopeStack;
@@ -64,35 +274,34 @@ class PHPWriter {
         }
         return this;
     }
-    assign(variable, expression, opts = {}) {
-        let lineComponents;
-        if (typeof variable === 'string') {
+    assign(assignee, expression, opts = {}) {
+        if (typeof assignee === 'string') {
+            assignee = new Var(assignee);
+        }
+        if (Array.isArray(assignee)) {
             if (this.scopeStack.length > 0) {
-                this.scopeStack[this.scopeStack.length - 1].push(variable);
+                this.scopeStack[this.scopeStack.length - 1].push(...assignee.filter(v => v instanceof Var).map(v => v.name));
             }
-            lineComponents = [`${variable} =`];
         }
         else {
-            if (this.scopeStack.length > 0) {
-                this.scopeStack[this.scopeStack.length - 1].push(...variable);
+            if (this.scopeStack.length > 0 && assignee instanceof Var) {
+                this.scopeStack[this.scopeStack.length - 1].push(assignee.name);
             }
-            lineComponents = variable.map(v => `${v} =`);
-        }
-        if (opts.return) {
-            lineComponents.splice(0, 0, "return");
         }
-        lineComponents.push(Expr.convertJsonToPHP(expression));
-        return this.append(!opts.chain ? lineComponents.join(" ") + ';' : lineComponents.join(" "));
+        return this.appendWithPossibleReturnAndChain(new Assignment(assignee, expression), opts);
     }
     return(expression) {
         return this.append(`return ${Expr.convertJsonToPHP(expression)};`);
     }
     static(variable, opts = {}) {
+        if (typeof variable === 'string') {
+            variable = new Var(variable);
+        }
         const initializer = opts.initializer ? Expr.convertJsonToPHP(opts.initializer) : "null";
-        this.append(`static ${variable} = ${initializer};`);
+        this.append(`static ${variable.toEnclosedForm()} = ${initializer};`);
         if (opts.withTest) {
-            this.if(`${variable} !== ${initializer}`)
-                .append(`return ${variable};`);
+            this.if(Op.binary(variable, "!==", new Literal(initializer)))
+                .append(`return ${Expr.convertJsonToPHP(variable)};`);
             if (opts.withTest !== 'chainable') {
                 this.endIf();
             }
@@ -104,16 +313,11 @@ class PHPWriter {
         return this;
     }
     call(func, args, opts = {}) {
-        const functionCall = `${func}(${args.map(Expr.convertJsonToPHP).join(", ")})`;
+        const functionCall = new Call(typeof func === 'string' ? Literal.name(func) : func, args);
         if (opts.assignTo) {
-            return this.assign(opts.assignTo, new Expr(functionCall), opts);
+            return this.assign(opts.assignTo, functionCall, opts);
         }
-        const lineComponents = [];
-        if (opts.return) {
-            lineComponents.push("return");
-        }
-        lineComponents.push(functionCall);
-        return this.append(!opts.chain ? lineComponents.join(" ") + ';' : lineComponents.join(" "));
+        return this.appendWithPossibleReturnAndChain(functionCall, opts);
     }
     action(name, contents, args = {}) {
         return this.actionOrFilter('action', name, contents, args);
@@ -133,7 +337,8 @@ class PHPWriter {
             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 + "(...)";
-            this.if(`doing_${type}(${Expr.convertJsonToPHP(name)})`).call(functionName, accountForAlreadyDoing === true ? [] : accountForAlreadyDoing);
+            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}.` });
@@ -187,18 +392,18 @@ class PHPWriter {
             name = this.generateFunctionName(args.assignToName);
         }
         if (args.includeExistenceCheck) {
-            this.if(`!function_exists(${Expr.convertJsonToPHP(name)})`);
+            this.if(Expr.call('function_exists', [name]).not());
         }
         else {
             this.openPHP();
         }
-        if (name !== false && args.assignToName) {
+        if (name instanceof Var) {
             if (this.scopeStack.length > 0) {
-                this.scopeStack[this.scopeStack.length - 1].push(name);
+                this.scopeStack[this.scopeStack.length - 1].push(name.name);
             }
         }
-        const declarationComponents = name === false ? [] : (args.assignToName ? [name, '='] : ["function"]);
-        let nameAndParameters = `${!name || args.assignToName ? 'function' : name}(${parameters.join(", ")})`;
+        const declarationComponents = name === false ? [] : (name instanceof Var ? [name, '='] : ["function"]);
+        let nameAndParameters = `${!name || name instanceof Var ? 'function' : name}(${parameters.join(", ")})`;
         if (args.useVars?.length) {
             let useVars = `use (${args.useVars.join(", ")})`;
             if (args.returnType) {
@@ -228,10 +433,10 @@ class PHPWriter {
         let count = 0;
         let name;
         do {
-            name = `${asVariable ? '$' : ''}plaudit_webpack_extensions__generated_function__${count++}`;
+            name = `plaudit_webpack_extensions__generated_function__${count++}`;
         } while (this.allocatedGeneratedFunctionNames.has(name));
         this.allocatedGeneratedFunctionNames.add(name);
-        return name;
+        return asVariable ? new Var(name) : name;
     }
     closePHP() {
         if (!this.printingInPHP) {
@@ -280,10 +485,13 @@ class PHPWriter {
         if (!scope?.length) {
             return this;
         }
-        for (const scopeItem of scope) {
+        const uniquenessSet = new Set();
+        const uniqueScopeItems = scope.filter(si => !uniquenessSet.has(si) && uniquenessSet.add(si));
+        for (const scopeItem of uniqueScopeItems) {
             this.allocatedGeneratedFunctionNames.delete(scopeItem);
         }
-        return this.append(`unset(${scope.join(", ")});`); // This is equivalent to calling this.call("unset", scope.map(v => new Expr(v))), but creates fewer objects
+        // This is equivalent to calling this.call("unset", scope.map(v => new Var(v))), but creates fewer objects
+        return this.append(`unset(${uniqueScopeItems.map(usi => "$" + usi).join(", ")});`);
     }
     /**
      * Pops the top scope from the stack WITHOUT calling unset for the variables that were assigned within it.
@@ -345,5 +553,14 @@ 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

@@ -9,7 +9,9 @@ const shared_1 = require("./shared");
 const common_config_helpers_1 = require("./utils/common-config-helpers");
 const AdditionalDependencyInjectorPlugin_1 = require("./plugins/AdditionalDependencyInjectorPlugin");
 const BrowserSyncPlugin_1 = require("./plugins/BrowserSyncPlugin");
+const dependency_extraction_webpack_plugin_config_builder_1 = require("./plugins/dependency-extraction-webpack-plugin-config-builder");
 const ExtensionsConfigFileGeneratorPlugin_1 = require("./plugins/ExtensionsConfigFileGeneratorPlugin");
+const ExtensionsConfigFileGeneratorPluginV1_1 = require("./plugins/ExtensionsConfigFileGeneratorPluginV1");
 const MiniCSSExtractPluginErrorCleaner_1 = require("./plugins/MiniCSSExtractPluginErrorCleaner");
 const PackageConfigSanityChecker_1 = require("./plugins/PackageConfigSanityChecker");
 const PlainEntrypointsConfigFileGeneratorPlugin_1 = require("./plugins/PlainEntrypointsConfigFileGeneratorPlugin");
@@ -18,11 +20,10 @@ const SpecialAssetHandlingPlugin_1 = require("./plugins/SpecialAssetHandlingPlug
 const VariablesJSMonitorPlugin_1 = require("./plugins/VariablesJSMonitorPlugin");
 const WPMLConfigBuilder_1 = require("./plugins/WPMLConfigBuilder");
 const static_configs_1 = require("./plugins/static-configs");
-const dependency_extraction_webpack_plugin_config_builder_1 = require("./plugins/dependency-extraction-webpack-plugin-config-builder");
+const UnifiedLoaderGenerator_1 = require("./plugins/UnifiedLoaderGenerator");
 const dependency_extraction_webpack_plugin_1 = __importDefault(require("@wordpress/dependency-extraction-webpack-plugin"));
 const fork_ts_checker_webpack_plugin_1 = __importDefault(require("fork-ts-checker-webpack-plugin"));
 const webpack_remove_empty_scripts_1 = __importDefault(require("webpack-remove-empty-scripts"));
-const UnifiedLoaderGenerator_1 = require("./plugins/UnifiedLoaderGenerator");
 function resolveLegacyBlockScriptsInFolder(folder) {
     const blockScriptEntrypoints = [];
     for (const blockDir of node_fs_1.default.readdirSync(folder)) {
@@ -431,17 +432,6 @@ function commonConfigProcessingPrep(config, webpackConfig) {
             }
         });
     }
-    fixedRules.push({
-        test: /block\.json$/i,
-        resourceQuery: /for-resource-tracking/i,
-        type: 'asset/resource',
-        generator: {
-            binary: false,
-            filename(pathData) {
-                return `${node_path_1.default.dirname(pathData.runtime)}/block[ext]`;
-            }
-        }
-    });
     return {
         entrypointFields, fixedRules, processingModules, scriptExtension,
         updateCurrentVariables: (value) => currentVariables = value
@@ -500,14 +490,17 @@ function makeBlocksWebpackConfig(config, commonConfig, webpackConfig, dest, src,
     return (0, common_config_helpers_1.commonMakeWebpackConfig)(config, commonConfig, webpackConfig, true, dest, src, srcRoot, (0, common_config_helpers_1.resolveEntryFromDirectory)(commonConfig, srcRoot, dest), plugins);
 }
 function makeExtensionsWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
-    plugins.push(new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest.destination));
+    const plugin = config.extensionsVersion > 1
+        ? new ExtensionsConfigFileGeneratorPlugin_1.ExtensionsConfigFileGeneratorPlugin(config, srcRoot, dest.destination)
+        : new ExtensionsConfigFileGeneratorPluginV1_1.ExtensionsConfigFileGeneratorPluginV1(dest.destination);
+    plugins.push(plugin);
     const entry = async () => {
         const rawEntrypoints = [];
         for await (const dirent of await promises_1.default.opendir(srcRoot)) {
             if (dirent.isFile() && !dirent.name.startsWith("~")) {
                 if (commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name)) {
                     const file = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
-                    rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(file, node_path_1.default.extname(file))), file]);
+                    rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(file, node_path_1.default.extname(file))), { import: file, library: { type: plugin.libraryType } }]);
                 }
             }
         }

package/package.json

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