@plaudit/webpack-extensions 2.62.0 → 2.62.1

package/build/plugins/PlainEntrypointsStyleBlockJSONPlugin.js

@@ -7,71 +7,27 @@ exports.PlainEntrypointsStyleBlockJSONPlugin = void 0;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const shared_1 = require("../shared");
 const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
-const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
-class PlainEntrypointsStyleBlockJSONPlugin {
+const promises_1 = __importDefault(require("node:fs/promises"));
+class PlainEntrypointsStyleBlockJSONPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
     config;
     blocksDest;
     webpackRemoveEmptyScriptsPlugin;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ collatableWorkableBlockInfo: {}, blocksDest: "", emittingWpmlXml: false }, "Block JSON v3");
-    static phaseTwoAttached = {};
-    id;
-    libraryType;
     constructor(config, blocksDest, webpackRemoveEmptyScriptsPlugin) {
+        super(`block-json-${blocksDest}`, [PlainEntrypointsStyleBlockJSONPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
         this.config = config;
         this.blocksDest = blocksDest;
         this.webpackRemoveEmptyScriptsPlugin = webpackRemoveEmptyScriptsPlugin;
-        this.id = Math.random().toString();
-        this.libraryType = `block-json-${this.blocksDest}`;
-        PlainEntrypointsStyleBlockJSONPlugin.semaphore.register(this.id);
-        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.register(this.id);
     }
     apply(compiler) {
-        webpack_1.library.EnableLibraryPlugin.setEnabled(compiler, this.libraryType);
+        super.apply(compiler);
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            PlainEntrypointsStyleBlockJSONPlugin.phaseTwoAttached[this.blocksDest] = false;
-            PlainEntrypointsStyleBlockJSONPlugin.semaphore.reset(this.id);
-            UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
-                if (!PlainEntrypointsStyleBlockJSONPlugin.phaseTwoAttached[this.blocksDest]) {
-                    PlainEntrypointsStyleBlockJSONPlugin.phaseTwoAttached[this.blocksDest] = true;
-                    compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
-                        const allSemaphoreData = (await PlainEntrypointsStyleBlockJSONPlugin.semaphore.wait())
-                            .reduce((acc, cur) => {
-                            (acc[cur.blocksDest] ?? (acc[cur.blocksDest] = [])).push(cur);
-                            return acc;
-                        }, {});
-                        const semaphoreData = allSemaphoreData[this.blocksDest];
-                        if (semaphoreData === undefined) {
-                            compilation.errors.push(new Error(`Semaphore data missing for ${this.blocksDest}`));
-                            return;
-                        }
-                        const workableBlockInfo = semaphoreData.map(sd => sd.collatableWorkableBlockInfo)
-                            .reduce((acc, cur) => {
-                            for (const [k, v] of Object.entries(cur)) {
-                                if (acc[k]) {
-                                    acc[k].workableBlockEntrypointsInfo.push(...v.workableBlockEntrypointsInfo);
-                                    if (!acc[k].sourcePath && v.sourcePath) {
-                                        acc[k].sourcePath = v.sourcePath;
-                                    }
-                                }
-                                else {
-                                    acc[k] = { ...v, workableBlockEntrypointsInfo: [...v.workableBlockEntrypointsInfo] };
-                                }
-                                acc[k].workableBlockEntrypointsInfo.sort((a, b) => {
-                                    return a.handle.localeCompare(b.handle) || a.entrypointField.localeCompare(b.entrypointField);
-                                });
-                            }
-                            return acc;
-                        }, {});
-                        const blockData = this.transformBlocks(compilation, workableBlockInfo, semaphoreData.some(sd => sd.emittingWpmlXml));
-                        this.emitBlockLoaderFile(compilation, blockData);
-                    });
-                }
-            });
             compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE, additionalAssets: true }, async (assets) => {
                 if (!("assets.json" in assets)) {
                     return;
@@ -126,10 +82,15 @@ class PlainEntrypointsStyleBlockJSONPlugin {
                             //TODO: Can we guarantee that entrypoint.name is always non-null?
                             const epBlockJson = entrypoint.name + ".json";
                             if (!applicableBlockJsonFiles[epBlockJson]) {
-                                applicableBlockJsonFiles[epBlockJson] = { sourcePath: srcPath, workableBlockEntrypointsInfo: [] };
+                                const blockJsonText = PlainEntrypointsStyleBlockJSONPlugin.extractAssetSource(compilation, epBlockJson)
+                                    ?? await promises_1.default.readFile(srcPath, 'utf-8');
+                                if (!blockJsonText) {
+                                    compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Unable to extract the source for ${epBlockJson}`, srcPath));
+                                    continue;
+                                }
+                                applicableBlockJsonFiles[epBlockJson] = { sourcePath: srcPath, workableBlockEntrypointsInfo: [], blockJsonText };
                             }
                             blockJsonOriginToOutputMapping[srcPath] = epBlockJson;
-                            compilation.emitAsset(epBlockJson, asset);
                         }
                     }
                     for (const { entrypoint, entrypointChunk, entrypointLibrary, srcPath } of relevantEntrypoints) {
@@ -198,8 +159,8 @@ class PlainEntrypointsStyleBlockJSONPlugin {
             delete blockData['__metadata'];
             new php_writer_1.PHPWriter()
                 .action("init", writer => {
-                writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [php_writer_1.Expr.__DIR__, new php_writer_1.Expr((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")),
-                    php_writer_1.Expr.__FILE__, new php_writer_1.Expr((0, shared_1.makeEmittableConfigPHP)(metadata, false, "\t")), null]);
+                writer.call("\\Plaudit\\Common\\ACF\\BlockManager::autoloadSubfoldersV3", [php_writer_1.Constants.__DIR__, new php_writer_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(blockData, false, "\t")),
+                    php_writer_1.Constants.__FILE__, new php_writer_1.EnclosedLiteral((0, shared_1.makeEmittableConfigPHP)(metadata, false, "\t")), null]);
             }, { accountForAlreadyDoing: true })
                 .emitAsset(compilation, node_path_1.default.join(this.blocksDest, "blockdir-loader.php"));
         }
@@ -212,18 +173,17 @@ class PlainEntrypointsStyleBlockJSONPlugin {
             .flatMap(bi => bi.workableBlockEntrypointsInfo)
             .sort((a, b) => a.handle.localeCompare(b.handle) || a.entrypointField.localeCompare(b.entrypointField));
         const blockData = {};
-        for (const [blockJsonAssetName, { sourcePath: blockJsonSourcePath, workableBlockEntrypointsInfo }] of Object.entries(collatedWorkableBlockInfo)) {
+        for (const [blockJsonAssetName, { sourcePath: blockJsonSourcePath, workableBlockEntrypointsInfo, blockJsonText }] of Object.entries(collatedWorkableBlockInfo)) {
             if (!blockJsonSourcePath) {
                 compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`${blockJsonAssetName} does not have a source path`, blockJsonAssetName));
                 continue;
             }
-            const sourceDir = node_path_1.default.dirname(blockJsonSourcePath);
-            const outputDir = node_path_1.default.join(compilation.compiler.outputPath, node_path_1.default.dirname(blockJsonAssetName));
-            const blockJsonText = PlainEntrypointsStyleBlockJSONPlugin.extractAssetSource(compilation, blockJsonAssetName);
             if (!blockJsonText) {
-                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`Unable to extract the source for ${blockJsonAssetName}`, node_path_1.default.join(sourceDir, 'block.json')));
+                compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`${blockJsonAssetName} does not have recorded text`, blockJsonAssetName));
                 continue;
             }
+            const sourceDir = node_path_1.default.dirname(blockJsonSourcePath);
+            const outputDir = node_path_1.default.join(compilation.compiler.outputPath, node_path_1.default.dirname(blockJsonAssetName));
             const blockJson = JSON.parse(blockJsonText);
             const pathsNeedRemapping = !this.config.standaloneBlocks && blockJson["plaudit"] !== "simple";
             PlainEntrypointsStyleBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "setup", pathsNeedRemapping, sourceDir, outputDir, compilation, true);
@@ -436,5 +396,39 @@ class PlainEntrypointsStyleBlockJSONPlugin {
             }
         }
     }
+    attachSecondPhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, async () => {
+            const allSemaphoreData = (await PlainEntrypointsStyleBlockJSONPlugin.semaphore.wait())
+                .reduce((acc, cur) => {
+                (acc[cur.blocksDest] ?? (acc[cur.blocksDest] = [])).push(cur);
+                return acc;
+            }, {});
+            const semaphoreData = allSemaphoreData[this.blocksDest];
+            if (semaphoreData === undefined) {
+                compilation.errors.push(new Error(`Semaphore data missing for ${this.blocksDest}`));
+                return;
+            }
+            const workableBlockInfo = semaphoreData.map(sd => sd.collatableWorkableBlockInfo)
+                .reduce((acc, cur) => {
+                for (const [k, v] of Object.entries(cur)) {
+                    if (acc[k]) {
+                        acc[k].workableBlockEntrypointsInfo.push(...v.workableBlockEntrypointsInfo);
+                        if (!acc[k].sourcePath && v.sourcePath) {
+                            acc[k].sourcePath = v.sourcePath;
+                        }
+                    }
+                    else {
+                        acc[k] = { ...v, workableBlockEntrypointsInfo: [...v.workableBlockEntrypointsInfo] };
+                    }
+                    acc[k].workableBlockEntrypointsInfo.sort((a, b) => {
+                        return a.handle.localeCompare(b.handle) || a.entrypointField.localeCompare(b.entrypointField);
+                    });
+                }
+                return acc;
+            }, {});
+            const blockData = this.transformBlocks(compilation, workableBlockInfo, semaphoreData.some(sd => sd.emittingWpmlXml));
+            this.emitBlockLoaderFile(compilation, blockData);
+        });
+    }
 }
 exports.PlainEntrypointsStyleBlockJSONPlugin = PlainEntrypointsStyleBlockJSONPlugin;

package/build/plugins/SpecialAssetHandlingPlugin.d.ts

@@ -1,12 +1,12 @@
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { type Compiler, type WebpackPluginInstance } from "webpack";
-export declare class SpecialAssetHandlingPlugin implements WebpackPluginInstance {
+import { Compilation, type Compiler } from "webpack";
+import { AbstractMultiPhaseLibraryPlugin } from "./AbstractMultiPhaseLibraryPlugin";
+export declare class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin {
     private readonly config;
     private static readonly semaphore;
-    private static hasAttachedAssetCollatorForCurrentBatch;
     private static validPathname?;
-    private readonly id;
     constructor(config: VerifiedPlauditWordpressWebpackConfig);
     apply(compiler: Compiler): void;
     private collateAssets;
+    protected attachSecondPhase(compilation: Compilation): void;
 }

package/build/plugins/SpecialAssetHandlingPlugin.js

@@ -10,32 +10,21 @@ const php_writer_1 = require("../utils/php-writer");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
 const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const webpack_1 = require("webpack");
-class SpecialAssetHandlingPlugin {
+const AbstractMultiPhaseLibraryPlugin_1 = require("./AbstractMultiPhaseLibraryPlugin");
+class SpecialAssetHandlingPlugin extends AbstractMultiPhaseLibraryPlugin_1.AbstractMultiPhaseLibraryPlugin {
     config;
     static semaphore = new pseduo_semaphore_1.PseudoSemaphore({}, "Special");
-    static hasAttachedAssetCollatorForCurrentBatch = false;
     static validPathname = undefined;
-    id;
     constructor(config) {
+        super("special-assets", [SpecialAssetHandlingPlugin.semaphore, UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore]);
         this.config = config;
-        this.id = Math.random().toString();
     }
     apply(compiler) {
         if (!this.config.useWebpackResourceFiltering) {
             return;
         }
-        SpecialAssetHandlingPlugin.semaphore.register(this.id);
-        UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.register(this.id);
+        super.apply(compiler);
         compiler.hooks.compilation.tap(this.constructor.name, compilation => {
-            SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch = false;
-            SpecialAssetHandlingPlugin.semaphore.reset(this.id);
-            UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reset(this.id);
-            compilation.hooks.beforeChunkIds.tap(this.constructor.name, () => {
-                if (!SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch) {
-                    SpecialAssetHandlingPlugin.hasAttachedAssetCollatorForCurrentBatch = true;
-                    compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, () => this.collateAssets(compilation));
-                }
-            });
             compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ANALYSE }, async (assets) => {
                 try {
                     const specialAssetData = {};
@@ -71,6 +60,7 @@ class SpecialAssetHandlingPlugin {
                 }
                 catch (e) {
                     SpecialAssetHandlingPlugin.semaphore.reject(this.id);
+                    UnifiedLoaderGenerator_1.UnifiedLoaderGenerator.semaphore.reject(this.id);
                     throw e;
                 }
             });
@@ -94,7 +84,8 @@ class SpecialAssetHandlingPlugin {
             (0, shared_1.emitResolveBaseUriFunction)(writer);
         }
         writer.action("wp_head", writer => {
-            writer.call("plaudit_webpack_extensions__resolve_base_uri", [php_writer_1.Expr.__DIR__], { assignTo: "$base_uri" }).closePHP();
+            const baseUriVar = new php_writer_1.Var("base_uri");
+            writer.call("plaudit_webpack_extensions__resolve_base_uri", [php_writer_1.Constants.__DIR__], { assignTo: baseUriVar }).closePHP();
             for (let [filename, { preload, fetchpriority, crossorigin }] of preloadedAssets) {
                 if (!preload) {
                     continue;
@@ -133,11 +124,14 @@ class SpecialAssetHandlingPlugin {
                     attributes.push(["crossorigin", crossorigin]);
                 }
                 const dynamicAttrs = attributes.map(([k, v]) => v ? `${k}="${v}"` : k).join(" ");
-                writer.append(`<link rel="preload" href="<?= esc_url($base_uri.'${filename}') ?>" ${dynamicAttrs}>`);
+                writer.append(`<link rel="preload" href="<?= ${php_writer_1.Expr.call("esc_url", [php_writer_1.Op.join(baseUriVar, filename)])} ?>" ${dynamicAttrs}>`);
             }
             writer.openPHP();
         });
         writer.emitAsset(compilation, outputFile);
     }
+    attachSecondPhase(compilation) {
+        compilation.hooks.processAssets.tapPromise({ name: this.constructor.name, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT }, () => this.collateAssets(compilation));
+    }
 }
 exports.SpecialAssetHandlingPlugin = SpecialAssetHandlingPlugin;

package/build/shared.d.ts

@@ -93,21 +93,6 @@ export declare function makeEmittableConfigPHP(data: any, asFullFile: boolean, p
 export type EntrypointFields = ["viewScriptModule", "scriptModule"] | ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];
 export declare const entrypointFields: ReadonlyArray<EntrypointFields[number]>;
 export declare function convertEntrypointFieldForAssetType(entrypointField: EntrypointFields[number], assetType: 'script' | 'style'): EntrypointFields[number];
-export type Sync<V> = {
-    sync: Promise<V>;
-    resolve(v: V): void;
-    reject(): void;
-    done: boolean;
-};
-type Readiness<V> = {
-    nonModule: Sync<V>;
-    module: Sync<V>;
-};
-export declare class SyncsManager<V> {
-    private readonly readinessMapping;
-    get(name: string): Readiness<V>;
-    private makeSync;
-}
 export declare function leadingSlashIt(pathOrSomething: string): string;
 export declare const scriptExtension: RegExp;
 export declare const scriptWithoutModuleExtension: RegExp;

package/build/shared.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.styleExtension = exports.scriptWithModuleExtension = exports.scriptWithoutModuleExtension = exports.scriptExtension = exports.SyncsManager = exports.entrypointFields = exports.standardLocationNames = void 0;
+exports.styleExtension = exports.scriptWithModuleExtension = exports.scriptWithoutModuleExtension = exports.scriptExtension = exports.entrypointFields = exports.standardLocationNames = void 0;
 exports.isRawAssetData = isRawAssetData;
 exports.determineCurrentSourceType = determineCurrentSourceType;
 exports.packBlockEntrypointInfoForSmuggling = packBlockEntrypointInfoForSmuggling;
@@ -87,26 +87,6 @@ function convertEntrypointFieldForAssetType(entrypointField, assetType) {
     const searchRep = assetType === 'script' ? ['tyle', 'cript'] : ['cript', 'tyle'];
     return entrypointField.replace(...searchRep);
 }
-class SyncsManager {
-    readinessMapping = new Map();
-    get(name) {
-        const res = this.readinessMapping.get(name);
-        if (res) {
-            return res;
-        }
-        this.readinessMapping.set(name, { nonModule: this.makeSync(), module: this.makeSync() });
-        return this.readinessMapping.get(name);
-    }
-    makeSync() {
-        const res = { done: false };
-        res.sync = new Promise((resolve, reject) => {
-            res.resolve = (v) => resolve(v);
-            res.reject = () => reject();
-        });
-        return res;
-    }
-}
-exports.SyncsManager = SyncsManager;
 function leadingSlashIt(pathOrSomething) {
     return pathOrSomething.startsWith('/') ? pathOrSomething : ('/' + pathOrSomething);
 }
@@ -154,19 +134,23 @@ function newWebpackErrorForFile(error, file) {
  * The primary benefit of emitting a function instead of baking its contents into each function that uses it is that it allows us to avoid recomputing the base uri multiple times
  */
 function emitResolveBaseUriFunction(writer) {
-    writer.function("plaudit_webpack_extensions__resolve_base_uri", ["$dir"], writer => {
+    const dir = new php_writer_1.Var("dir");
+    const baseUris = new php_writer_1.Var("base_uris");
+    const assignmentTarget = new php_writer_1.ArrayAccess(baseUris, dir);
+    const path = new php_writer_1.Var("path");
+    writer.function("plaudit_webpack_extensions__resolve_base_uri", [dir], writer => {
         writer
-            .static("$base_uris", { initializer: [] })
-            .if("isset($base_uris[$dir])")
-            .return(new php_writer_1.Expr("$base_uris[$dir]"))
-            .elseIf("str_starts_with($dir, ABSPATH)")
-            .append("$path = ltrim(substr($dir, strlen(ABSPATH)), '/');")
-            .elseIf("str_starts_with($dir, '/workspace/website')")
-            .append("$path = ltrim(substr($dir, 18), '/');")
+            .static(baseUris, { initializer: [] })
+            .if(php_writer_1.Expr.isset(assignmentTarget))
+            .return(assignmentTarget)
+            .elseIf(php_writer_1.Expr.call("str_starts_with", [dir, php_writer_1.Constants.ABSPATH]))
+            .assign(path, php_writer_1.Expr.call("ltrim", [php_writer_1.Expr.call("substr", [dir, php_writer_1.Expr.call("strlen", [php_writer_1.Constants.ABSPATH])]), "/"]))
+            .elseIf(php_writer_1.Expr.call("str_starts_with", [dir, "/workspace/website"]))
+            .assign(path, php_writer_1.Expr.call("ltrim", [php_writer_1.Expr.call("substr", [dir, 18]), "/"]))
             .else()
             .call("error_log", ["UNABLE TO FIGURE OUT WHAT THE RELATIVE PATH TO THE BUILT FILES DIRECTORY SHOULD BE"])
-            .append("$path = '';")
+            .assign(path, "")
             .endIf()
-            .call("trailingslashit", [new php_writer_1.Expr("home_url($path)")], { return: true, assignTo: "$base_uris[$dir]" });
+            .call("trailingslashit", [php_writer_1.Expr.call("home_url", [path])], { return: true, assignTo: assignmentTarget });
     }, { returnType: "string", includeExistenceCheck: true });
 }

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

@@ -1,23 +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;
-    static readonly __FILE__: Expr;
-    static readonly __DIR__: Expr;
-    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;
@@ -39,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;
@@ -91,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 {};