@plaudit/webpack-extensions 2.54.0 → 2.55.1

package/build/utils/common-config-helpers.js

@@ -0,0 +1,336 @@
+"use strict";
+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 = void 0;
+exports.scriptOrStyleTest = scriptOrStyleTest;
+exports.joinPossiblyAbsolutePaths = joinPossiblyAbsolutePaths;
+exports.groupEntrypointsByAssetFile = groupEntrypointsByAssetFile;
+exports.resolveEntryFromDirectory = resolveEntryFromDirectory;
+exports.commonMakeWebpackConfig = commonMakeWebpackConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const copy_webpack_plugin_1 = __importDefault(require("copy-webpack-plugin"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const BlockJSONManagingPlugin_1 = require("../plugins/BlockJSONManagingPlugin");
+exports.scriptWithoutModuleExtension = /\.[jt]sx?$/;
+exports.scriptWithModuleExtension = /\.m[jt]sx?$/;
+exports.styleExtension = /\.(p?c|sa)ss$/;
+function scriptOrStyleTest(entryPath, scriptExtension) {
+    return scriptExtension.test(entryPath) ? "script" : (exports.styleExtension.test(entryPath) ? "style" : "");
+}
+let isInThemeCache = undefined;
+function isInTheme() {
+    return isInThemeCache ?? (isInThemeCache = node_fs_1.default.existsSync(node_path_1.default.join(process.cwd(), "theme.json")));
+}
+function joinPossiblyAbsolutePaths(...paths) {
+    return paths.filter((p) => !!p)
+        .reduce((res, p) => !res || node_path_1.default.isAbsolute(p) ? p : node_path_1.default.join(res, p), '') || '.';
+}
+function groupEntrypointsByAssetFile(entrypoints, entrypointNameExtractor) {
+    const seenPaths = new Map();
+    for (const entrypoint of entrypoints) {
+        const entrypointName = entrypointNameExtractor(entrypoint);
+        const key = entrypointName.substring(0, entrypointName.length - node_path_1.default.extname(entrypointName).length);
+        let seen = seenPaths.get(key);
+        if (seen === undefined) {
+            seenPaths.set(key, seen = []);
+        }
+        seen.push(entrypoint);
+    }
+    return seenPaths;
+}
+function mapToRealEntrypoints(entrypoint, dir, args = {}) {
+    const { mapper = ep => ep, lazyDependent, associatedQuery, destDir } = args;
+    return (Array.isArray(entrypoint) ? entrypoint : [entrypoint])
+        .map(ep => joinPossiblyAbsolutePaths(dir, mapper(ep)))
+        .filter(ep => node_fs_1.default.statSync(ep, { throwIfNoEntry: false })?.isFile())
+        .map(ep => {
+        const parsedEntrypoint = node_path_1.default.parse(ep);
+        return [joinPossiblyAbsolutePaths(destDir, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name), { import: ep, lazyDependent, associatedQuery }];
+    });
+}
+function parseEntrypointsJSON(dir, dest) {
+    const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(dir, 'entrypoints.json'), 'utf8'));
+    if (Array.isArray(entrypointsJSON)) {
+        return mapToRealEntrypoints(entrypointsJSON, dir, { destDir: dest.destination });
+    }
+    else {
+        return Object.entries(entrypointsJSON).map(([name, config]) => {
+            if (typeof config === 'string') {
+                return [name, joinPossiblyAbsolutePaths(dir, config)];
+            }
+            else if (Array.isArray(config)) {
+                return [name, config.map(c => joinPossiblyAbsolutePaths(dir, c))];
+            }
+            else {
+                if (typeof config.import === 'string') {
+                    config.import = joinPossiblyAbsolutePaths(dir, config.import);
+                }
+                else {
+                    config.import = config.import.map(c => joinPossiblyAbsolutePaths(dir, c));
+                }
+                return [name, config];
+            }
+        });
+    }
+}
+function determineEntrypointType(entrypoint, scriptExtension) {
+    let res = scriptOrStyleTest(entrypoint[0], scriptExtension);
+    if (res) {
+        return res;
+    }
+    if (typeof entrypoint[1] === 'string') {
+        return scriptOrStyleTest(entrypoint[1], scriptExtension);
+    }
+    else if (Array.isArray(entrypoint[1])) {
+        return entrypoint[1].reduce((prior, ep) => prior || scriptOrStyleTest(ep, scriptExtension), "");
+    }
+    else if (typeof entrypoint[1].import === 'string') {
+        return scriptOrStyleTest(entrypoint[1].import, scriptExtension);
+    }
+    else {
+        return entrypoint[1].import.reduce((prior, ep) => prior || scriptOrStyleTest(ep, scriptExtension), "");
+    }
+}
+function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
+    const entrypointBasename = entrypointName.substring(0, entrypointName.length - node_path_1.default.extname(entrypointName).length);
+    const parts = [];
+    if (type) {
+        parts.push(type);
+    }
+    if (typeCounts[type] ?? (typeCounts[type] = 0)) {
+        parts.push(typeCounts[type].toString());
+    }
+    typeCounts[type] += 1;
+    return `${entrypointBasename}_${parts.join('-')}${node_path_1.default.extname(entrypointName)}`;
+}
+function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts, scriptExtension) {
+    const type = determineEntrypointType(entrypoint, scriptExtension);
+    let potentialKey = injectTypeAndCountToEntrypointName(entrypoint[0], type, typeCounts);
+    while (entry[potentialKey]) {
+        potentialKey = injectTypeAndCountToEntrypointName(entrypoint[0], type, typeCounts);
+    }
+    entry[potentialKey] = entrypoint[1];
+}
+function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
+    const { entrypointFields, processingModules, scriptExtension } = commonConfig;
+    return async () => {
+        const loadingEntrypoints = [];
+        for await (const dirent of await promises_1.default.opendir(srcRoot)) {
+            if (!dirent.isDirectory()) {
+                continue;
+            }
+            const dir = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
+            loadingEntrypoints.push(new Promise(async (resolve) => {
+                const rawEntrypoints = [];
+                const wpmlFiles = [];
+                try {
+                    const blockJSON = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dir, 'block.json'), 'utf8'));
+                    const blockJSONChunkName = node_path_1.default.join(dest.destination, node_path_1.default.relative(srcRoot, dir), "block.json");
+                    for (const key of entrypointFields) {
+                        if (key in blockJSON) {
+                            rawEntrypoints.push(...mapToRealEntrypoints(blockJSON[key], dir, { mapper: ep => ep.startsWith("file:") ? ep.substring(5) : ep, lazyDependent: blockJSONChunkName, destDir: dest.destination }));
+                        }
+                    }
+                    wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
+                    BlockJSONManagingPlugin_1.BlockJSONManagingPlugin.recordBlockJSONAssetSourceDir(blockJSONChunkName, dir);
+                }
+                catch (e) {
+                    try {
+                        const packageJSON = JSON.parse(await promises_1.default.readFile(node_path_1.default.join(dir, 'package.json'), 'utf8'));
+                        rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['main'], dir, { destDir: dest.destination }));
+                        rawEntrypoints.push(...mapToRealEntrypoints(packageJSON['style'], dir, { destDir: dest.destination }));
+                    }
+                    catch (e) {
+                        try {
+                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest));
+                        }
+                        catch (e) {
+                            // This just means that the directory doesn't contain any declared entrypoints.
+                        }
+                    }
+                }
+                if (!processingModules) {
+                    try {
+                        const wpmlFilePath = node_path_1.default.join(dir, "wpml-config.xml");
+                        await promises_1.default.access(wpmlFilePath);
+                        wpmlFiles.push(wpmlFilePath);
+                    }
+                    catch (e) {
+                        // This just means that the file doesn't exist
+                    }
+                }
+                resolve([rawEntrypoints, wpmlFiles]);
+            }));
+        }
+        const allEntrypoints = await Promise.all(loadingEntrypoints);
+        const perAssetPathGroupedEntrypoints = groupEntrypointsByAssetFile(allEntrypoints.flatMap(e => e[0]), e => e[0]);
+        const currentEntry = {};
+        for (const groupedEntrypoints of perAssetPathGroupedEntrypoints.values()) {
+            if (groupedEntrypoints.length === 1 && groupedEntrypoints[0] !== undefined) {
+                currentEntry[groupedEntrypoints[0][0]] = groupedEntrypoints[0][1];
+            }
+            else {
+                const typeCounts = {};
+                for (const entrypoint of groupedEntrypoints) {
+                    addPotentiallyDuplicatedEntrypointName(currentEntry, entrypoint, typeCounts, scriptExtension);
+                }
+            }
+        }
+        // This is used to allow for block.json dependencies to correctly account for name-deduplication
+        for (const [key, entry] of Object.entries(currentEntry)) {
+            if (typeof entry === 'object' && !Array.isArray(entry) && 'lazyDependent' in entry && typeof entry.lazyDependent === 'string') {
+                BlockJSONManagingPlugin_1.BlockJSONManagingPlugin.recordRawDependency(entry.lazyDependent, key);
+            }
+        }
+        if (!processingModules) {
+            const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
+            try {
+                await promises_1.default.access(node_path_1.default.join(srcRoot, "wpml-config.xml"));
+                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles] };
+            }
+            catch (e) {
+                // If the wpml-config.xml file does not exist, just "import" the other files that will be used to build the emitted version
+                if (wpmlEntrypointFiles.length) {
+                    currentEntry["wpml-config.xml"] = { import: wpmlEntrypointFiles };
+                }
+            }
+        }
+        return currentEntry;
+    };
+}
+function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirectory, dest, src, srcRoot, entry, plugins) {
+    const { standaloneBlocks, variablesFilePath } = config;
+    const { fixedRules, processingModules, updateCurrentVariables } = commonConfig;
+    const outPath = joinPossiblyAbsolutePaths(process.cwd(), config.outputDir);
+    let publicPath = webpackConfig.output?.publicPath;
+    if (isInTheme()) {
+        let prefix = process.cwd();
+        while (prefix.length > 5 && node_path_1.default.basename(prefix) !== "wp-content") {
+            prefix = node_path_1.default.dirname(prefix);
+        }
+        if (prefix.length > 5) {
+            prefix = node_path_1.default.dirname(prefix);
+            publicPath = `/${node_path_1.default.relative(prefix, outPath)}/`;
+        }
+    }
+    let viableRoots = [...(Array.isArray(webpackConfig.context) ? webpackConfig.context : [webpackConfig.context ?? process.cwd()])];
+    if (Array.isArray(srcRoot)) {
+        viableRoots.push(...(srcIsDirectory ? srcRoot : srcRoot.map(s => node_path_1.default.dirname(s))));
+    }
+    else {
+        viableRoots.push(srcIsDirectory ? srcRoot : node_path_1.default.dirname(srcRoot));
+    }
+    let wpContentHolderDirectory = process.cwd();
+    while (wpContentHolderDirectory.length > 5) {
+        if (node_path_1.default.basename(wpContentHolderDirectory) === 'wp-content') {
+            wpContentHolderDirectory = node_path_1.default.dirname(wpContentHolderDirectory);
+            if (wpContentHolderDirectory.length > 5) {
+                viableRoots.push(wpContentHolderDirectory);
+            }
+            break;
+        }
+        wpContentHolderDirectory = node_path_1.default.dirname(wpContentHolderDirectory);
+    }
+    const distinctViableRoots = new Set();
+    viableRoots = viableRoots.filter(value => distinctViableRoots.has(value) ? false : distinctViableRoots.add(value) && true);
+    let outputLibrary;
+    if (typeof dest === 'object' && dest.externalize) {
+        if (Array.isArray(dest.externalize) || typeof dest.externalize === 'string') {
+            outputLibrary = {
+                name: dest.externalize,
+                type: "assign"
+            };
+        }
+        else {
+            const originalLibrary = webpackConfig.output?.library;
+            if (originalLibrary && typeof originalLibrary === 'object' && !Array.isArray(originalLibrary)) {
+                outputLibrary = {
+                    ...originalLibrary,
+                    ...dest.externalize
+                };
+            }
+            else {
+                outputLibrary = dest.externalize;
+            }
+        }
+    }
+    else {
+        outputLibrary = webpackConfig.output?.library;
+    }
+    const canCopyFiles = srcIsDirectory && src !== dest;
+    const possiblePlugins = canCopyFiles
+        ? plugins.map(plugin => !processingModules && plugin.constructor.name === 'CopyPlugin'
+            ? new copy_webpack_plugin_1.default({
+                patterns: [{
+                        from: standaloneBlocks ? '**/(block.json|*.(php|twig|svg))' : '**/(block.json|*.(asset\.php|svg))',
+                        to: typeof dest === 'string' ? dest : dest.destination,
+                        context: srcRoot /* canCopyFiles can only be true if srcRoot is a string, so this is safe  */, noErrorOnMissing: true
+                    }]
+            })
+            : plugin)
+        : (srcIsDirectory
+            ? plugins.filter(plugin => plugin.constructor.name !== 'CopyPlugin' && plugin.constructor.name !== 'CleanWebpackPlugin')
+            : plugins.filter(plugin => plugin.constructor.name !== 'CopyPlugin'));
+    return {
+        ...webpackConfig,
+        devtool: 'source-map',
+        mode: "production",
+        output: {
+            ...webpackConfig.output,
+            path: outPath,
+            chunkFilename: 'webpack-chunks/[id].js',
+            publicPath: publicPath,
+            library: outputLibrary
+        },
+        optimization: {
+            ...webpackConfig.optimization,
+            splitChunks: {
+                ...(webpackConfig.optimization?.splitChunks || {}),
+                cacheGroups: {
+                    style: {
+                        // This is a flagrant abuse of cache groups, but it fixes a persistent problem wherein the dependencies and versions of scripts and styles were bleeding into each-other
+                        type: 'css/mini-extract',
+                        chunks: 'all',
+                        enforce: true,
+                        name(_, chunks, cacheGroupKey) {
+                            const chunkName = chunks.find(chunk => chunk.name)?.name;
+                            // We use "__${cacheGroupKey}__" instead of "${cacheGroupKey}-" to make it easier to remove when generating the filename
+                            const filename = `__${cacheGroupKey}__${node_path_1.default.basename(chunkName)}`;
+                            const dirname = node_path_1.default.dirname(chunkName);
+                            return dirname === '.' ? filename : `${dirname}/${filename}`;
+                        }
+                    },
+                    default: false
+                }
+            }
+        },
+        module: {
+            ...webpackConfig.module,
+            rules: fixedRules
+        },
+        resolve: {
+            ...webpackConfig.resolve,
+            roots: viableRoots,
+            extensions: ['.mjsx', '.mjs', '.mtsx', '.mts', '.jsx', '.tsx', '.ts', '...']
+        },
+        stats: config.stats,
+        plugins: config.outputDir ? possiblePlugins : possiblePlugins.filter(plugin => plugin.constructor.name !== 'CleanWebpackPlugin'),
+        entry() {
+            if (variablesFilePath) {
+                delete require.cache[require.resolve(variablesFilePath)];
+                updateCurrentVariables(require(variablesFilePath));
+            }
+            return entry();
+        },
+        performance: {
+            ...webpackConfig.performance,
+            assetFilter(assetFilename) {
+                // We don't want to warn about the sizes of incompressible assets
+                return !/\.(map|svg|png|jpe?g|gif)$/i.test(assetFilename);
+            }
+        }
+    };
+}

package/build/{wordpress-scripts-wrapper → utils}/php-serializer.d.ts

@@ -2,5 +2,5 @@ type Config = {
     objectsAsArrays?: boolean;
     excludedKeys?: string[];
 };
-export default function phpSerialize(value: any, config?: Config): string;
+export declare function phpSerialize(value: any, config?: Config): string;
 export {};

package/build/{wordpress-scripts-wrapper → utils}/php-serializer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = phpSerialize;
+exports.phpSerialize = phpSerialize;
 function phpSerialize(value, config) {
     switch (typeof value) {
         case "undefined":

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

@@ -0,0 +1,54 @@
+import { AssetInfo, Compilation } from "webpack";
+export declare class Expr {
+    private readonly value;
+    private readonly raw;
+    static readonly jsonToPHPConverter: (obj: unknown, parentIndent?: string) => string;
+    static readonly convertJsonToPHP: (obj: unknown) => string;
+    constructor(value: string, raw?: boolean);
+    toString(): string;
+}
+export type ActionOrFilterArgs = {
+    priority?: number | Expr;
+    functionArgParameters?: string[];
+    useVars?: string[];
+};
+export type FunctionCreationArgs = {
+    includeExistenceCheck?: boolean;
+    useVars?: string[];
+    returnType?: string;
+};
+export declare class PHPWriter {
+    private readonly inlineFirstLine;
+    private buffer;
+    private indentation;
+    private printingInPHP;
+    private fileNamespace;
+    private useList;
+    constructor(inlineFirstLine?: boolean);
+    indent(): this;
+    outdent(): this;
+    append(...lines: (string | Expr)[]): this;
+    static(variable: string, opts?: {
+        initializer?: string | Expr;
+        withTest?: boolean | 'chainable';
+    }): this;
+    linebreak(): this;
+    call(func: string, args: unknown[], opts?: {
+        chain?: boolean;
+        assignTo?: string;
+    }): this;
+    action(name: string | Expr, contents: (writer: this) => void, args?: ActionOrFilterArgs): this;
+    filter(name: string | Expr, contents: (writer: this) => void, args?: ActionOrFilterArgs): this;
+    actionOrFilter(type: 'action' | 'filter', name: string | Expr, contents: (writer: this) => void, args: ActionOrFilterArgs): this;
+    if(condition: string): this;
+    elseIf(condition: string): this;
+    else(): this;
+    endIf(): this;
+    function(name: string, parameters: string[], body: (writer: this) => void, args?: FunctionCreationArgs): this;
+    closePHP(): this;
+    openPHP(): this;
+    namespace(namespace: string): this;
+    use(...uses: string[]): this;
+    toString(): string;
+    emitAsset(compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
+}

package/build/utils/php-writer.js

@@ -0,0 +1,195 @@
+"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.Expr = void 0;
+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) {
+        this.value = value;
+        this.raw = raw;
+    }
+    toString() {
+        return this.raw ? this.value : Expr.jsonToPHPConverter(this.value);
+    }
+}
+exports.Expr = Expr;
+class PHPWriter {
+    inlineFirstLine;
+    buffer = [];
+    indentation = "";
+    printingInPHP = true;
+    fileNamespace = "";
+    useList = [];
+    constructor(inlineFirstLine = false) {
+        this.inlineFirstLine = inlineFirstLine;
+    }
+    indent() {
+        this.indentation += "\t";
+        return this;
+    }
+    outdent() {
+        this.indentation = this.indentation.slice(0, -1);
+        return this;
+    }
+    append(...lines) {
+        for (const line of lines) {
+            this.buffer.push(`${this.indentation}${line}`);
+        }
+        return this;
+    }
+    static(variable, opts = {}) {
+        const initializer = opts.initializer ? Expr.convertJsonToPHP(opts.initializer) : "null";
+        this.append(`static ${variable} = ${initializer};`);
+        if (opts.withTest) {
+            this.if(`${variable} !== ${initializer}`)
+                .append(`return ${variable};`);
+            if (opts.withTest !== 'chainable') {
+                this.endIf();
+            }
+        }
+        return this;
+    }
+    linebreak() {
+        this.buffer.push("");
+        return this;
+    }
+    call(func, args, opts = {}) {
+        const line = `${func}(${args.map(Expr.convertJsonToPHP).join(", ")})${opts.chain === true ? "" : ";"}`;
+        return this.append(opts.assignTo ? `${opts.assignTo} = ${line}` : line);
+    }
+    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 = [] } = args;
+        // The trailing comma inside the first item is necessary
+        const declarationComponents = [`${Expr.convertJsonToPHP(name)},`, `function(${functionArgParameters.join(", ")})`];
+        if (useVars.length > 0) {
+            declarationComponents.push(`use (${useVars.join(", ")})`);
+        }
+        declarationComponents.push("{");
+        this.openPHP().append(`add_${type}(${declarationComponents.join(" ")}`);
+        this.indent();
+        contents(this);
+        this.openPHP().outdent();
+        const actionOrFilterArgs = ["}"];
+        const accepted_args = Math.max(functionArgParameters.length, 1); // This avoids us unnecessarily setting the accepted_args value to 0 for actions
+        if (priority !== 10) {
+            actionOrFilterArgs.push(priority.toString());
+            if (accepted_args !== 1) {
+                actionOrFilterArgs.push(accepted_args.toString());
+            }
+        }
+        else if (accepted_args !== 1) {
+            actionOrFilterArgs.push(`accepted_args: ${accepted_args}`);
+        }
+        return this.append(actionOrFilterArgs.join(", ") + ");");
+    }
+    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 (args.includeExistenceCheck) {
+            this.if(`!function_exists('${name}')`);
+        }
+        else {
+            this.openPHP();
+        }
+        let nameAndParameters = `${name}(${parameters.join(", ")})`;
+        const declarationComponents = ["function",];
+        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();
+        body(this);
+        this.openPHP().outdent().append("}");
+        if (args.includeExistenceCheck) {
+            return this.endIf();
+        }
+        return this;
+    }
+    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;
+    }
+    toString() {
+        const fileContents = [];
+        let canInline = true;
+        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 (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;

package/build/utils/pseduo-semaphore.d.ts

@@ -0,0 +1,13 @@
+export declare class PseudoSemaphore<T> {
+    private readonly defaultValue;
+    private flagSet;
+    private readonly flags;
+    constructor(defaultValue: T);
+    register(id: string): void;
+    resolve(id: string, value: T): void;
+    reject(id: string): void;
+    reset(id: string): void;
+    private getFlag;
+    private initializeFlag;
+    wait(): Promise<T[]>;
+}

package/build/utils/pseduo-semaphore.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoSemaphore = void 0;
+class PseudoSemaphore {
+    defaultValue;
+    flagSet = 0;
+    flags = new Map();
+    constructor(defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+    register(id) {
+        if (this.flags.has(id)) {
+            throw new Error();
+        }
+        this.initializeFlag(id);
+        this.resolve(id, this.defaultValue);
+    }
+    resolve(id, value) {
+        const flag = this.getFlag(id);
+        flag[1].resolve(value); // This is deliberately unsafe - I would rather see a cascading failure than a silent one
+        flag[2] = true;
+    }
+    reject(id) {
+        const flag = this.getFlag(id);
+        flag[1].reject(); // This is deliberately unsafe - I would rather see a cascading failure than a silent one
+        flag[2] = true;
+    }
+    reset(id) {
+        const flag = this.getFlag(id);
+        // We reject if we reset early to avoid any permanently-hanging promises
+        if (!flag[2]) {
+            flag[1].reject(); // This is deliberately unsafe - I would rather see a cascading failure than a silent one
+        }
+        this.initializeFlag(id);
+    }
+    getFlag(id) {
+        const flag = this.flags.get(id);
+        if (flag) {
+            return flag;
+        }
+        throw new Error();
+    }
+    initializeFlag(id) {
+        const controller = {};
+        const promise = new Promise((resolve, reject) => {
+            controller.resolve = resolve;
+            controller.reject = reject;
+        });
+        this.flags.set(id, [promise, controller, false, Date.now()]);
+        this.flagSet++;
+        promise.catch(() => { });
+    }
+    async wait() {
+        let currentFlagSet;
+        let res;
+        do {
+            currentFlagSet = this.flagSet;
+            res = await Promise.all(this.flags.values().toArray().sort((a, b) => a[3] - b[3]).map(flag => flag[0]));
+        } while (currentFlagSet !== this.flagSet);
+        return res;
+    }
+}
+exports.PseudoSemaphore = PseudoSemaphore;