@plaudit/webpack-extensions 2.70.1 → 2.72.0

package/build/utils/php-writer.js

@@ -1,634 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PHPWriter = exports.Constants = exports.Assignment = exports.validPHPLabel = exports.FirstClassCallable = exports.Parameter = 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 {
-    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() { }
-    // noinspection JSUnusedGlobalSymbols - this technically-unused method is necessary for TypeScript to differentiate subclasses of Expr from any
-    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 {
-    static closers = Object.freeze({ "(": ")", "[": "]", "{": "}" });
-    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 of(expression, enclosed = false, enclosureClose) {
-        if (expression instanceof PHPWriter) {
-            expression = expression.toString({ includeOpenPHP: false, includeNamespaceAndUse: false }).trim();
-        }
-        if (typeof enclosed === 'string') {
-            return new EnclosableLiteral(expression, enclosed, enclosureClose ?? AbstractEnclosableExpression.closers[enclosed] ?? 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 concat(...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 Parameter extends Expr {
-    value;
-    name;
-    constructor(value, name) {
-        super();
-        this.value = value;
-        this.name = name;
-    }
-    toString() {
-        return this.name ? `${this.name}: ${Expr.convertJsonToPHP(this.value)}` : Expr.convertJsonToPHP(this.value);
-    }
-}
-exports.Parameter = Parameter;
-class FirstClassCallable extends ParenthesesEnclosableExpression {
-    name;
-    constructor(name) {
-        super();
-        this.name = name;
-    }
-    static from(literal) {
-        return new FirstClassCallable(Literal.name(literal));
-    }
-    toString() {
-        return this.name.toEnclosedForm() + "(...)";
-    }
-}
-exports.FirstClassCallable = FirstClassCallable;
-exports.validPHPLabel = /^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$/; // This is from https://www.php.net/manual/en/functions.user-defined.php
-class Assignment extends ParenthesesEnclosableExpression {
-    value;
-    push;
-    assignees;
-    constructor(assignees, value, push = false) {
-        super();
-        this.value = value;
-        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 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() {
-        if (this.push) {
-            return this.assignees[0].toEnclosedForm() + "[] = " + Expr.convertJsonToPHP(this.value);
-        }
-        return [...this.assignees.map(t => t.toEnclosedForm()), Expr.convertJsonToPHP(this.value)].join(" = ");
-    }
-}
-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;
-    useList;
-    allocatedGeneratedFunctionNames;
-    isSubwriter;
-    printingInPHP;
-    buffer = [];
-    indentation;
-    fileNamespace = "";
-    myOpenedScopes = 0;
-    constructor(inlineFirstLine = false, scopeStack = [], useList = [], allocatedGeneratedFunctionNames = new Set(), isSubwriter = false, printingInPHP = true, initialIndentation = 0) {
-        this.inlineFirstLine = inlineFirstLine;
-        this.scopeStack = scopeStack;
-        this.useList = useList;
-        this.allocatedGeneratedFunctionNames = allocatedGeneratedFunctionNames;
-        this.isSubwriter = isSubwriter;
-        this.printingInPHP = printingInPHP;
-        this.indentation = "\t".repeat(initialIndentation);
-    }
-    createSubwriter() {
-        return new PHPWriter(false, this.scopeStack, this.useList, this.allocatedGeneratedFunctionNames, true, this.printingInPHP, this.indentation.length)
-            .setIndentation(this.indentation.length);
-    }
-    indent() {
-        this.indentation += "\t";
-        return this;
-    }
-    outdent() {
-        this.indentation = this.indentation.slice(0, -1);
-        return this;
-    }
-    setIndentation(level) {
-        this.indentation = "\t".repeat(level);
-        return this;
-    }
-    /**
-     * @param lines These are treated as literal *regardless of their types*
-     */
-    append(...lines) {
-        for (const line of lines) {
-            this.buffer.push(`${this.indentation}${line}`);
-        }
-        return this;
-    }
-    /**
-     * @param expr This is treated as literal *regardless of its type*
-     * @param opts flags to add additional markup around the expression
-     */
-    appendExpr(expr, opts = {}) {
-        let expression;
-        if (isEnclosableExpression(expr)) {
-            expression = opts.chain ? expr.toEnclosedForm() : expr.toString();
-        }
-        else if (opts.chain && expr instanceof Expr) {
-            throw new Error(`Cannot chain non-enclosable expressions`);
-        }
-        else {
-            expression = expr.toString();
-        }
-        if (opts.chain && expr instanceof Expr && !isEnclosableExpression(expr)) {
-            throw new Error(`Cannot chain non-enclosable expressions`);
-        }
-        const res = (opts.return ? "return " : "") + expression;
-        return this.append(!opts.chain ? res + ';' : res);
-    }
-    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(...assignee.filter(v => v instanceof Var).map(v => v.name));
-            }
-        }
-        else {
-            if (this.scopeStack.length > 0 && assignee instanceof Var) {
-                this.scopeStack[this.scopeStack.length - 1].push(assignee.name);
-            }
-        }
-        return this.appendExpr(new Assignment(assignee, expression), opts);
-    }
-    return(expression) {
-        return this.appendExpr(Expr.convertJsonToPHP(expression), { return: true });
-    }
-    static(variable, opts = {}) {
-        if (typeof variable === 'string') {
-            variable = new Var(variable);
-        }
-        const initializer = opts.initializer ? Expr.convertJsonToPHP(opts.initializer) : "null";
-        this.append(`static ${variable.toEnclosedForm()} = ${initializer};`);
-        if (opts.withTest) {
-            this.if(Op.binary(variable, "!==", new Literal(initializer)))
-                .append(`return ${Expr.convertJsonToPHP(variable)};`);
-            if (opts.withTest !== 'chainable') {
-                this.endIf();
-            }
-        }
-        return this;
-    }
-    linebreak() {
-        this.buffer.push("");
-        return this;
-    }
-    /**
-     * @param func This is treated as literal *regardless of its type*
-     * @param args
-     * @param opts
-     */
-    call(func, args, opts = {}) {
-        const functionCall = new Call(typeof func === 'string' ? Literal.name(func) : func, args);
-        if (opts.assignTo) {
-            return this.assign(opts.assignTo, functionCall, opts);
-        }
-        return this.appendExpr(functionCall, opts);
-    }
-    action(name, contents, args = {}) {
-        return this.actionOrFilter('action', name, contents, args);
-    }
-    filter(name, contents, args = {}) {
-        return this.actionOrFilter('filter', name, contents, args);
-    }
-    actionOrFilter(type, name, contents, args) {
-        const { priority = 10, functionArgParameters = [], useVars = [], accountForAlreadyDoing } = args;
-        const functionWriter = this.createSubwriter();
-        let declarationFunction;
-        if (accountForAlreadyDoing) {
-            if (functionArgParameters.length > 0 && accountForAlreadyDoing === true) {
-                console.trace(`The accountForAlreadyDoing flag must be set to a list of default parameters when applied to ${type}s that take arguments`);
-            }
-            this.openPHP().openScope();
-            const functionName = functionWriter.function(true, functionArgParameters, contents, { useVars, scopeActionDescription: `closing the function call for the ${name} ${type}.`, assignToName: true });
-            this.append(functionWriter.toString().trim());
-            declarationFunction = new FirstClassCallable(functionName);
-            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}.` });
-            declarationFunction = Literal.of(functionWriter);
-        }
-        // The trailing comma inside the first item is necessary
-        const additionArgs = [name, declarationFunction];
-        const accepted_args = Math.max(functionArgParameters.length, 1); // This avoids us unnecessarily setting the accepted_args value to 0 for actions
-        if (priority !== 10) {
-            additionArgs.push(priority);
-            if (accepted_args !== 1) {
-                additionArgs.push(accepted_args);
-            }
-        }
-        else if (accepted_args !== 1) {
-            additionArgs.push(new Parameter(accepted_args, "accepted_args"));
-        }
-        const line = Expr.call(`add_${type}`, additionArgs);
-        if (accountForAlreadyDoing) {
-            return this
-                .else()
-                .appendExpr(line)
-                .endIf()
-                .closeScope();
-        }
-        return this.openPHP().appendExpr(line);
-    }
-    if(condition) {
-        return this.openPHP().append(`if (${condition}) {`).indent();
-    }
-    elseIf(condition) {
-        return this.openPHP().outdent().append(`} else if (${condition}) {`).indent();
-    }
-    else() {
-        return this.openPHP().outdent().append(`} else {`).indent();
-    }
-    endIf() {
-        return this.openPHP().outdent().append("}");
-    }
-    function(name, parameters, body, args = {}) {
-        if (name === false) {
-            if (args.includeExistenceCheck) {
-                console.trace('Anonymous functions cannot have their existence checked for');
-            }
-            if (args.assignToName) {
-                console.trace('Anonymous functions cannot be assigned to a name');
-            }
-        }
-        if (typeof name === 'string') {
-            if (!exports.validPHPLabel.test(name)) {
-                throw new Error(`'${name}' is not a valid function name. Please see https://www.php.net/manual/en/functions.user-defined.php for what constitutes one`);
-            }
-        }
-        const returningString = name === true;
-        if (name === true) {
-            name = this.generateFunctionName(args.assignToName);
-        }
-        if (args.includeExistenceCheck) {
-            this.if(Expr.call('function_exists', [name]).not());
-        }
-        else {
-            this.openPHP();
-        }
-        if (name instanceof Var) {
-            if (this.scopeStack.length > 0) {
-                this.scopeStack[this.scopeStack.length - 1].push(name.name);
-            }
-        }
-        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) {
-                useVars += `: ${args.returnType}`;
-            }
-            declarationComponents.push(nameAndParameters, useVars);
-        }
-        else {
-            if (args.returnType) {
-                nameAndParameters += `: ${args.returnType}`;
-            }
-            declarationComponents.push(nameAndParameters);
-        }
-        declarationComponents.push("{");
-        this.append(declarationComponents.join(' '));
-        this.indent();
-        // 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: args.scopeActionDescription ?? `closing the "${name || "anonymous"}" function`, usePopScopeInstead: true });
-        this.openPHP().outdent().append(name !== false && args.assignToName ? "};" : "}");
-        if (args.includeExistenceCheck) {
-            this.endIf();
-        }
-        return returningString ? name : this;
-    }
-    generateFunctionName(asVariable = false) {
-        let count = 0;
-        let name;
-        do {
-            name = `plaudit_webpack_extensions__generated_function__${count++}`;
-        } while (this.allocatedGeneratedFunctionNames.has(name));
-        this.allocatedGeneratedFunctionNames.add(name);
-        return asVariable ? new Var(name) : name;
-    }
-    closePHP() {
-        if (!this.printingInPHP) {
-            return this;
-        }
-        this.printingInPHP = false;
-        return this.append("?>");
-    }
-    openPHP() {
-        if (this.printingInPHP) {
-            return this;
-        }
-        this.printingInPHP = true;
-        return this.append("<?php");
-    }
-    namespace(namespace) {
-        this.fileNamespace = namespace;
-        return this;
-    }
-    use(...uses) {
-        for (const use of uses) {
-            if (!this.useList.find(u => u.toLowerCase() === use.toLowerCase())) {
-                this.useList.push(use);
-            }
-        }
-        return this;
-    }
-    require(filePath, args = {}) {
-        return this.requireOrInclude('require', filePath, args);
-    }
-    include(filePath, args = {}) {
-        return this.requireOrInclude('include', filePath, args);
-    }
-    requireOrInclude(type, filePath, args) {
-        const command = args.once ? `${type}_once` : type;
-        if (args.dirRelative && typeof filePath === 'string' && !filePath.startsWith("/")) {
-            filePath = "/" + filePath;
-        }
-        const path = args.dirRelative ? Op.concat(Constants.__DIR__, filePath) : Expr.convertJsonToPHP(filePath);
-        return this.appendExpr(`${command} ${path}`, args);
-    }
-    /**
-     * 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([]);
-        this.myOpenedScopes++;
-        return this;
-    }
-    /**
-     * Pops the top scope from the stack AND unsets all variables that were assigned within it
-     */
-    closeScope() {
-        if (!this.myOpenedScopes) {
-            return this;
-        }
-        this.myOpenedScopes--;
-        const scope = this.scopeStack.pop();
-        if (!scope?.length) {
-            return this;
-        }
-        const uniquenessSet = new Set();
-        const uniqueScopeItems = scope.filter(si => !uniquenessSet.has(si) && uniquenessSet.add(si));
-        for (const scopeItem of uniqueScopeItems) {
-            this.allocatedGeneratedFunctionNames.delete(scopeItem);
-        }
-        // 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.
-     * This is used to allow function bodies to be safely created without disrupting their containing scope.
-     */
-    popScope() {
-        if (this.myOpenedScopes) {
-            this.scopeStack.pop();
-            this.myOpenedScopes--;
-        }
-        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(args = this.isSubwriter ? { includeOpenPHP: false, includeNamespaceAndUse: false } : {}) {
-        if (this.myOpenedScopes) {
-            console.trace("toString() was called on a PHPWriter that has a dangling scope");
-        }
-        const fileContents = [];
-        let canInline = true;
-        if (args.includeNamespaceAndUse !== false) {
-            if (this.fileNamespace) {
-                canInline = false;
-                fileContents.push(`namespace ${this.fileNamespace};`);
-            }
-            if (this.useList.length) {
-                canInline = false;
-                fileContents.push(...this.useList.map(use => `use ${use};`));
-            }
-        }
-        fileContents.push(...this.buffer);
-        if (args.includeOpenPHP === false) {
-            return fileContents.join("\n");
-        }
-        if (this.inlineFirstLine && canInline) {
-            return `<?php ${fileContents.join("\n")}`;
-        }
-        else if (fileContents.find(line => line.length > 0)) {
-            return "<?php\n" + fileContents.join("\n");
-        }
-        else {
-            return "<?php";
-        }
-    }
-    emitAsset(compilation, file, assetInfo) {
-        const contents = this.toString() + "\n";
-        compilation[file in compilation.assets ? 'updateAsset' : 'emitAsset'](file, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents), ...assetInfo });
-    }
-}
-exports.PHPWriter = PHPWriter;