@plaudit/webpack-extensions 2.61.2 → 2.62.1

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

@@ -1,21 +1,125 @@
 import { AssetInfo, Compilation } from "webpack";
-export declare class Expr {
-    private readonly value;
-    private readonly raw;
+export declare abstract class Expr {
     static readonly jsonToPHPConverter: (obj: unknown, parentIndent?: string) => string;
     static readonly convertJsonToPHP: (obj: unknown) => string;
-    constructor(value: string, raw?: boolean);
+    protected constructor();
+    abstract toString(): string;
+    typeName(): string;
+    static isset(...checks: (Var | ArrayAccess | ObjectAccess)[]): Call;
+    static call(name: string, args: ConstructorParameters<typeof Call>[1]): Call;
+}
+export interface EnclosableExpression extends Expr {
+    toEnclosedForm(): string;
+    not(): Not;
+}
+export interface PotentiallyWriteableExpression extends EnclosableExpression {
+    readonly potentiallyWritable: true;
+}
+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 {
+    abstract toEnclosedForm(): string;
+    not(): Not;
+}
+export declare abstract class ParenthesesEnclosableExpression extends AbstractEnclosableExpression {
+    toEnclosedForm(): string;
+}
+export declare abstract class EnclosedExpression extends AbstractEnclosableExpression {
+    toEnclosedForm(): string;
+}
+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 name(expression: string): EnclosedLiteral;
+}
+export declare class EnclosedLiteral extends Literal implements EnclosableExpression {
+    constructor(expression: string);
+    toEnclosedForm(): string;
+    not(): Not;
+}
+export declare class EnclosableLiteral extends Literal implements EnclosableExpression {
+    private readonly enclosureOpen;
+    private readonly enclosureClose;
+    constructor(expression: string, enclosureOpen: string, enclosureClose: string);
+    toEnclosedForm(): string;
+    not(): Not;
+}
+export declare class Var extends EnclosedExpression implements PotentiallyWriteableExpression {
+    readonly name: string;
+    readonly potentiallyWritable = true;
+    constructor(name: string);
+    toString(): string;
+}
+export declare class Op extends ParenthesesEnclosableExpression {
+    readonly operator: string;
+    readonly args: readonly unknown[];
+    constructor(operator: string, ...args: unknown[]);
+    toString(): string;
+    static binary(left: unknown, operator: string, right: unknown): Op;
+    static join(...args: unknown[]): Op;
+}
+export declare class Not extends ParenthesesEnclosableExpression {
+    readonly expression: EnclosableExpression;
+    constructor(expression: EnclosableExpression);
+    toString(): string;
+}
+type AtLeastOneArray<T> = [T, ...T[]];
+type ReadonlyAtLeastOneArray<T> = readonly [T, ...T[]];
+export type Accessor = Expr | string | number;
+export type AccessorOrAccessorArray = Accessor | AtLeastOneArray<Accessor>;
+export declare abstract class Access extends EnclosedExpression implements PotentiallyWriteableExpression {
+    readonly target: EnclosableExpression;
+    readonly potentiallyWritable = true;
+    readonly accesses: ReadonlyAtLeastOneArray<Accessor>;
+    constructor(target: EnclosableExpression, accesses: AccessorOrAccessorArray);
+    abstract endsWithCall(): boolean;
+    abstract endsWithPotentiallyWritableExpression(): boolean;
+}
+export declare class ArrayAccess extends Access {
     toString(): string;
+    endsWithCall(): boolean;
+    endsWithPotentiallyWritableExpression(): boolean;
+}
+export declare class ObjectAccess extends Access {
+    static readonly validObjectKey: RegExp;
+    toString(): string;
+    endsWithCall(): boolean;
+    endsWithPotentiallyWritableExpression(): boolean;
+}
+export declare class Call extends EnclosedExpression implements PotentiallyWriteableExpression {
+    readonly callee: string | EnclosableExpression;
+    readonly args: readonly unknown[];
+    readonly potentiallyWritable = true;
+    constructor(callee: string | EnclosableExpression, args: readonly unknown[]);
+    toString(): string;
+}
+type Assignable = EnclosedExpression & PotentiallyWriteableExpression;
+export declare class Assignment extends ParenthesesEnclosableExpression {
+    readonly value: unknown;
+    readonly push: boolean;
+    readonly assignees: ReadonlyAtLeastOneArray<Assignable>;
+    constructor(assignees: Assignable, value: unknown, push: true);
+    constructor(assignees: Assignable | AtLeastOneArray<Assignable>, value: unknown, push?: false | undefined);
+    toString(): string;
+}
+export declare abstract class Constants {
+    static readonly __FILE__: EnclosedLiteral;
+    static readonly __DIR__: EnclosedLiteral;
+    static readonly ABSPATH: EnclosedLiteral;
 }
 export type ActionOrFilterArgs = {
     priority?: number | Expr;
     functionArgParameters?: string[];
-    useVars?: string[];
+    useVars?: Var[];
     accountForAlreadyDoing?: boolean | Parameters<PHPWriter['call']>[1];
 };
 export type FunctionCreationArgs = {
     includeExistenceCheck?: boolean;
-    useVars?: string[];
+    useVars?: Var[];
     returnType?: string;
     assignToName?: boolean;
     scopeActionDescription?: string;
@@ -37,31 +141,33 @@ export declare class PHPWriter {
     outdent(): this;
     setIndentation(level: number): this;
     append(...lines: (string | Expr)[]): this;
-    assign(variable: string | string[], expression: unknown | Expr, opts?: {
+    assign(assignee: ConstructorParameters<typeof Assignment>[0] | string, expression: unknown, opts?: {
         chain?: boolean;
         return?: boolean;
     }): this;
     return(expression: unknown | Expr): this;
-    static(variable: string, opts?: {
-        initializer?: unknown | Expr;
+    static(variable: Var | string, opts?: {
+        initializer?: unknown | Literal;
         withTest?: boolean | 'chainable';
     }): this;
     linebreak(): this;
-    call(func: string, args: unknown[], opts?: {
+    call(func: string | EnclosableExpression, args: unknown[], opts?: {
         chain?: boolean;
-        assignTo?: string | string[];
+        assignTo?: ConstructorParameters<typeof Assignment>[0];
         return?: boolean;
     }): this;
     action(name: string | Expr, contents: (writer: PHPWriter) => void, args?: ActionOrFilterArgs): this;
     filter(name: string | Expr, contents: (writer: PHPWriter) => void, args?: ActionOrFilterArgs): this;
     actionOrFilter(type: 'action' | 'filter', name: string | Expr, contents: (writer: PHPWriter) => void, args: ActionOrFilterArgs): this;
-    if(condition: string): this;
-    elseIf(condition: string): this;
+    if(condition: Expr): this;
+    elseIf(condition: Expr): this;
     else(): this;
     endIf(): this;
-    function(name: true, parameters: string[], body: (writer: PHPWriter) => void, args?: FunctionCreationArgs): string;
-    function(name: string | false, parameters: string[], body: (writer: PHPWriter) => void, args?: FunctionCreationArgs): this;
-    generateFunctionName(asVariable?: boolean): string;
+    function(name: true, parameters: (string | Var)[], body: (writer: PHPWriter) => void, args?: FunctionCreationArgs): Var;
+    function(name: string | Var | false, parameters: (string | Var)[], body: (writer: PHPWriter) => void, args?: FunctionCreationArgs): this;
+    generateFunctionName(asVariable: true): Var;
+    generateFunctionName(asVariable?: false | undefined): string;
+    generateFunctionName(asVariable?: boolean): string | Var;
     closePHP(): this;
     openPHP(): this;
     namespace(namespace: string): this;
@@ -89,4 +195,11 @@ 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,23 +3,236 @@ 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);
-    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.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");
+            }
+        }
+        else {
+        }
     }
     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;
@@ -62,35 +275,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();
             }
@@ -102,16 +314,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);
@@ -131,7 +338,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}.` });
@@ -185,18 +393,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) {
@@ -226,10 +434,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) {
@@ -278,10 +486,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.call("unset", scope.map(v => new Expr(v)));
+        // 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.
@@ -343,5 +554,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

@@ -8,21 +8,22 @@ const node_path_1 = __importDefault(require("node:path"));
 const shared_1 = require("./shared");
 const common_config_helpers_1 = require("./utils/common-config-helpers");
 const AdditionalDependencyInjectorPlugin_1 = require("./plugins/AdditionalDependencyInjectorPlugin");
-const BlockJSONManagingPlugin_1 = require("./plugins/BlockJSONManagingPlugin");
 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");
+const PlainEntrypointsStyleBlockJSONPlugin_1 = require("./plugins/PlainEntrypointsStyleBlockJSONPlugin");
 const SpecialAssetHandlingPlugin_1 = require("./plugins/SpecialAssetHandlingPlugin");
 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)) {
@@ -377,7 +378,8 @@ function buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest,
     handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins);
     const removeEmptyScriptsPlugin = new webpack_remove_empty_scripts_1.default({
         stage: webpack_remove_empty_scripts_1.default.STAGE_AFTER_PROCESS_PLUGINS,
-        extensions: ['css', 'scss', 'sass', 'less', 'styl', 'pcss']
+        extensions: ['css', 'scss', 'sass', 'less', 'styl', 'pcss'],
+        ignore: /block\.json/
     });
     plugins.push(removeEmptyScriptsPlugin, new MiniCSSExtractPluginErrorCleaner_1.MiniCSSExtractPluginErrorCleaner());
     plugins.push(new UnifiedLoaderGenerator_1.UnifiedLoaderGenerator(config));
@@ -390,7 +392,7 @@ function buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest,
     else {
         const localAssumeGlobalizedPlauditLibraries = dest.assumeGlobalizedPlauditLibraries ?? assumeGlobalizedPlauditLibraries;
         const wantsGroupedDepData = combineAssetMetadata
-            && ((!processingModules && sourceType === "blocks" /* SourceType.blocks */)
+            && ((sourceType === "blocks" /* SourceType.blocks */)
                 || (extensionsVersion > 1 && sourceType === "extensions" /* SourceType.extensions */)
                 || (plainEntrypointsVersion > 1 && sourceType === "plain" /* SourceType.plain */));
         const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(externals, localAssumeGlobalizedPlauditLibraries, wantsGroupedDepData, dest.externalize);
@@ -465,7 +467,6 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
             }
             case "plain" /* SourceType.plain */:
                 if (!srcIsDirectory) {
-                    //TODO: We need to filter this when in directory mode as well
                     const primarySrcRoot = typeof srcRoot === 'string' ? srcRoot : srcRoot[0];
                     if (!scriptExtension.test(primarySrcRoot) && !shared_1.styleExtension.test(primarySrcRoot)) {
                         return undefined;
@@ -481,22 +482,25 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
 }
 function makeBlocksWebpackConfig(config, commonConfig, webpackConfig, dest, src, srcRoot, plugins) {
     const { processingModules } = commonConfig;
-    const blockJSONManagingPlugin = new BlockJSONManagingPlugin_1.BlockJSONManagingPlugin(config.standaloneBlocks, processingModules, dest.destination);
+    const blockJSONManagingPlugin = new PlainEntrypointsStyleBlockJSONPlugin_1.PlainEntrypointsStyleBlockJSONPlugin(config, dest.destination, plugins.find(p => p instanceof webpack_remove_empty_scripts_1.default));
     plugins.push(blockJSONManagingPlugin);
     if (config.processTranslationConfigs && !processingModules) {
-        plugins.push(new WPMLConfigBuilder_1.WPMLConfigBuilderPlugin(blockJSONManagingPlugin, dest.destination));
+        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);
 }
 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.61.2",
+  "version": "2.62.1",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
     "/build"