@plaudit/webpack-extensions 2.53.1 → 2.55.0

package/build/{wordpress-scripts-wrapper → plugins}/AdditionalDependencyInjectorPlugin.js

@@ -16,9 +16,9 @@ class AdditionalDependencyInjectorPlugin {
         this.addExternalizedDep = addExternalizedDep;
     }
     apply(compiler) {
-        compiler.hooks.thisCompilation.tap("AdditionalDependencyInjectorPlugin", compilation => {
+        compiler.hooks.thisCompilation.tap(this.constructor.name, compilation => {
             compilation.hooks.processAssets.tap({
-                name: "AdditionalDependencyInjectorPlugin_ProcessAssets_AddFakeModules",
+                name: `${this.constructor.name}_ProcessAssets_AddFakeModules`,
                 stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
             }, () => {
                 const usableEntrypointTest = this.processingModules ? /\.m[jt]sx?$/i : /\.[jt]sx?$/i;
@@ -40,7 +40,7 @@ class AdditionalDependencyInjectorPlugin {
                 }
             });
             compilation.hooks.processAssets.tap({
-                name: "AdditionalDependencyInjectorPlugin_ProcessAssets_RemoveFakeModules",
+                name: `${this.constructor.name}_ProcessAssets_RemoveFakeModules`,
                 stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT
             }, () => {
                 for (const entrypoint of compilation.entrypoints.values()) {

package/build/{wordpress-scripts-wrapper → plugins}/BlockJSONManagingPlugin.d.ts

@@ -2,6 +2,7 @@ import { Compilation, type Compiler, type WebpackPluginInstance } from "webpack"
 export declare class BlockJSONManagingPlugin implements WebpackPluginInstance {
     private readonly standaloneBlocks;
     private readonly processingModules;
+    private readonly blocksDest;
     static readonly mappableModuleKeys: readonly ["viewScriptModule", "scriptModule"];
     static readonly mappableNonModuleKeys: readonly ["editorScript", "script", "viewScript", "editorStyle", "style", "viewStyle"];
     private static readonly styleExtensionPattern;
@@ -11,9 +12,9 @@ export declare class BlockJSONManagingPlugin implements WebpackPluginInstance {
     private static readonly blockJsonRawDependenciesMap;
     private static readonly blockJSONAssetSourceDirs;
     private static readonly blockJsonAssetKeyMapping;
-    private static readonly blockJsonAssetKeyReadinessMapping;
+    private static readonly syncsManager;
     readonly additionalMetadata: Map<string, any>;
-    constructor(standaloneBlocks: boolean, processingModules: boolean);
+    constructor(standaloneBlocks: boolean, processingModules: boolean | undefined, blocksDest: string);
     static recordRawDependency(entrypoint: string, dependency: string): void;
     static recordBlockJSONAssetSourceDir(entrypoint: string, source: string): void;
     apply(compiler: Compiler): void;
@@ -32,10 +33,9 @@ export declare class BlockJSONManagingPlugin implements WebpackPluginInstance {
     private static populateEntrypointsMap;
     private registerBlockJsonProcessor;
     private static normalizeRenderTemplate;
-    private static getSyncs;
-    private static makeSync;
-    private static getAssetDetails;
+    private getAssetDetails;
     private static getAssetDataAccountingForCSS;
     private static findFirstChunkFileWithExtension;
     private static getChunkFilesByRuntimeName;
+    private stripBlocksDest;
 }

package/build/{wordpress-scripts-wrapper → plugins}/BlockJSONManagingPlugin.js

@@ -7,11 +7,12 @@ exports.BlockJSONManagingPlugin = 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 json_to_php_but_with____injection_1 = __importDefault(require("./json-to-php-but-with-__-injection"));
+const shared_1 = require("../shared");
 const webpack_1 = require("webpack");
 class BlockJSONManagingPlugin {
     standaloneBlocks;
     processingModules;
+    blocksDest;
     static mappableModuleKeys = ["viewScriptModule", "scriptModule"];
     static mappableNonModuleKeys = ["editorScript", "script", "viewScript", "editorStyle", "style", "viewStyle"];
     static styleExtensionPattern = /\.(p?c|sa)ss$/i;
@@ -21,11 +22,12 @@ class BlockJSONManagingPlugin {
     static blockJsonRawDependenciesMap = new Map();
     static blockJSONAssetSourceDirs = new Map();
     static blockJsonAssetKeyMapping = new Map();
-    static blockJsonAssetKeyReadinessMapping = new Map();
+    static syncsManager = new shared_1.SyncsManager();
     additionalMetadata = new Map();
-    constructor(standaloneBlocks, processingModules) {
+    constructor(standaloneBlocks, processingModules, blocksDest) {
         this.standaloneBlocks = standaloneBlocks;
         this.processingModules = processingModules;
+        this.blocksDest = blocksDest;
     }
     static recordRawDependency(entrypoint, dependency) {
         let deps = BlockJSONManagingPlugin.blockJsonRawDependenciesMap.get(entrypoint);
@@ -254,7 +256,7 @@ class BlockJSONManagingPlugin {
                         }
                     }
                 }
-                const syncs = BlockJSONManagingPlugin.getSyncs(name);
+                const syncs = BlockJSONManagingPlugin.syncsManager.get(name);
                 let assetKeyMappings = BlockJSONManagingPlugin.blockJsonAssetKeyMapping.get(name);
                 if (!assetKeyMappings) {
                     BlockJSONManagingPlugin.blockJsonAssetKeyMapping.set(name, assetKeyMappings = {});
@@ -404,7 +406,7 @@ class BlockJSONManagingPlugin {
                         if (cfg) {
                             if (Array.isArray(cfg)) {
                                 for (let i = 0; i < cfg.length; i++) {
-                                    const assetDetails = BlockJSONManagingPlugin
+                                    const assetDetails = this
                                         .getAssetDetails(blockFolder, config["name"], cfg[i], rawAssetData, derivedFilesMap, mappableKey, usedHandles);
                                     if (assetDetails) {
                                         (assetDetails.isCss ? styleHandles : scriptHandles)[assetDetails.handle] = assetDetails.handleData;
@@ -413,7 +415,7 @@ class BlockJSONManagingPlugin {
                                 }
                             }
                             else {
-                                const assetDetails = BlockJSONManagingPlugin
+                                const assetDetails = this
                                     .getAssetDetails(blockFolder, config["name"], cfg, rawAssetData, derivedFilesMap, mappableKey, usedHandles);
                                 if (assetDetails) {
                                     (assetDetails.isCss ? styleHandles : scriptHandles)[assetDetails.handle] = assetDetails.handleData;
@@ -425,22 +427,17 @@ class BlockJSONManagingPlugin {
                 }
                 sortedBlockDirConfigData = Object.fromEntries([
                     ["__metadata", { version: 3, ...Object.fromEntries(this.additionalMetadata.entries()), scriptHandles, styleHandles }],
-                    ...blockDirConfigs.map(entry => [entry[0], Object.fromEntries(Object.entries(entry[1]).filter(e => e[0] !== '$schema'))])
+                    ...blockDirConfigs.map(entry => [this.stripBlocksDest(entry[0]), Object.fromEntries(Object.entries(entry[1]).filter(e => e[0] !== '$schema'))])
                 ]);
                 compilation.deleteAsset("assets.json");
             }
             else {
                 sortedBlockDirConfigData = Object.fromEntries([
                     ["__metadata", { version: 1, ...Object.fromEntries(this.additionalMetadata.entries()) }],
-                    ...blockDirConfigs.map(entry => [entry[0], Object.fromEntries(Object.entries(entry[1]).filter(e => e[0] !== '$schema'))])
+                    ...blockDirConfigs.map(entry => [this.stripBlocksDest(entry[0]), Object.fromEntries(Object.entries(entry[1]).filter(e => e[0] !== '$schema'))])
                 ]);
             }
-            compilation.emitAsset("blockdir.config.php", new webpack_1.sources.RawSource("<?php return "
-                + json_to_php_but_with____injection_1.default.make({ indent: "\t", linebreak: "\n", shortArraySyntax: true })(sortedBlockDirConfigData, "")
-                    .replaceAll(/(\n\t*)\[\s+],/gs, "$1[],")
-                    .replaceAll(/\[\n\t+([^\n]+)\n\t+]/gs, (_, inner) => `[${inner.trim()}]`)
-                    .replaceAll(/'rest' => \[\n\t+(\[(?:'[^']+')?]),\n\t+('[^']+')(?:,\n\t+(\[[^\n]+]))?\n\t+]/gs, (_, deps, hash, args) => `'rest' => [${[deps, hash, args].filter(value => !!value).join(", ")}]`)
-                + ";"));
+            compilation.emitAsset(node_path_1.default.join(this.blocksDest, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(sortedBlockDirConfigData)));
         });
     }
     static normalizeRenderTemplate(json, pathsNeedRemapping, sourceDir, outputDir, compilation) {
@@ -494,23 +491,7 @@ class BlockJSONManagingPlugin {
             }
         }
     }
-    static getSyncs(name) {
-        const res = BlockJSONManagingPlugin.blockJsonAssetKeyReadinessMapping.get(name);
-        if (res) {
-            return res;
-        }
-        BlockJSONManagingPlugin.blockJsonAssetKeyReadinessMapping.set(name, { nonModule: BlockJSONManagingPlugin.makeSync(), module: BlockJSONManagingPlugin.makeSync() });
-        return BlockJSONManagingPlugin.blockJsonAssetKeyReadinessMapping.get(name);
-    }
-    static makeSync() {
-        const res = { done: false };
-        res.sync = new Promise((resolve, reject) => {
-            res.resolve = (v) => resolve(v);
-            res.reject = () => reject();
-        });
-        return res;
-    }
-    static getAssetDetails(blockFolder, blockName, asset, rawAssetData, derivedFilesMap, mappableKey, usedHandles) {
+    getAssetDetails(blockFolder, blockName, asset, rawAssetData, derivedFilesMap, mappableKey, usedHandles) {
         if (!asset.startsWith("file:./")) {
             return undefined;
         }
@@ -541,7 +522,7 @@ class BlockJSONManagingPlugin {
         if (!assetData) {
             return undefined;
         }
-        let handle = src.substring(0, src.length - (isCss ? 4 : 3));
+        let handle = this.stripBlocksDest(src.substring(0, src.length - (isCss ? 4 : 3)));
         if (blockName && handle.startsWith(blockName.substring(blockName.indexOf("/") + 1) + "/")) {
             handle = blockName + handle.substring(handle.indexOf("/"));
         }
@@ -554,7 +535,7 @@ class BlockJSONManagingPlugin {
         const rest = isCss || mappableKey.startsWith("editor")
             ? [assetData.dependencies, assetData.version]
             : [assetData.dependencies, assetData.version, { strategy: 'defer' }];
-        return { isCss, handle, handleData: { src, rest } };
+        return { isCss, handle, handleData: { src: this.stripBlocksDest(src), rest } };
     }
     static getAssetDataAccountingForCSS(src, rawAssetData) {
         if (rawAssetData[src]) {
@@ -587,5 +568,8 @@ class BlockJSONManagingPlugin {
         }
         return [...files];
     }
+    stripBlocksDest(item) {
+        return this.blocksDest && item.startsWith(this.blocksDest + "/") ? item.substring(this.blocksDest.length + 1 /* we also need to drop the "/" */) : item;
+    }
 }
 exports.BlockJSONManagingPlugin = BlockJSONManagingPlugin;

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.d.ts

@@ -0,0 +1,13 @@
+import { type Compiler, type WebpackPluginInstance } from "webpack";
+export declare class ExtensionsConfigFileGeneratorPlugin implements WebpackPluginInstance {
+    private readonly extensionsPath;
+    private readonly version;
+    private readonly extensionsDest;
+    private static readonly semaphore;
+    private static cache;
+    private readonly id;
+    constructor(extensionsPath: string, version: 1 | 2, extensionsDest: string);
+    apply(compiler: Compiler): void;
+    private makeVersionOneAfterProcessAssets;
+    private stripExtensionsDest;
+}

package/build/plugins/ExtensionsConfigFileGeneratorPlugin.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionsConfigFileGeneratorPlugin = void 0;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const shared_1 = require("../shared");
+const php_serializer_1 = require("../utils/php-serializer");
+const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
+const webpack_1 = require("webpack");
+class ExtensionsConfigFileGeneratorPlugin {
+    extensionsPath;
+    version;
+    extensionsDest;
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore({ assets: [], setupFiles: [] });
+    static cache = undefined;
+    id;
+    constructor(extensionsPath, version, extensionsDest) {
+        this.extensionsPath = extensionsPath;
+        this.version = version;
+        this.extensionsDest = extensionsDest;
+        this.id = Math.random().toString();
+        ExtensionsConfigFileGeneratorPlugin.semaphore.register(this.id);
+    }
+    apply(compiler) {
+        compiler.hooks.make.tapPromise(this.constructor.name, async (compilation) => {
+            if (!compilation.contextDependencies.has(this.extensionsPath)) {
+                compilation.contextDependencies.add(this.extensionsPath);
+            }
+            const emissionPromises = [];
+            for (const setupFilePath of await promises_1.default.readdir(this.extensionsPath)) {
+                if (setupFilePath.endsWith("-setup.php")) {
+                    const setupFileSourcePath = node_path_1.default.join(this.extensionsPath, setupFilePath);
+                    compilation.fileDependencies.add(setupFileSourcePath);
+                    emissionPromises.push(promises_1.default.readFile(setupFileSourcePath).then(contents => {
+                        return compilation.emitAsset(node_path_1.default.join(this.extensionsDest, setupFilePath), new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents) });
+                    }));
+                }
+            }
+            await Promise.all(emissionPromises);
+        });
+        if (this.version === 2) {
+            const tapName = { name: `${this.constructor.name}_ProcessBlockJSONFiles`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT };
+            compiler.hooks.compilation.tap(this.constructor.name, compilation => {
+                ExtensionsConfigFileGeneratorPlugin.cache = undefined;
+                ExtensionsConfigFileGeneratorPlugin.semaphore.reset(this.id);
+                compilation.hooks.processAssets.tapPromise(tapName, async (assets) => {
+                    try {
+                        //TODO: Add handling of extracted CSS from JS
+                        //TODO: It should be possible to use EntryPoints to determine the "original" file
+                        //TODO: Use the version hash of the original file, but not its dependencies for the additional file's "rest" parameter (see BlockJSONManagingPlugin.ts for how to do so)
+                        //TODO: There is no reason to not use basically the exact same logic to implement support for this in plain file contexts
+                        //TODO: BlockJSONManagingPlugin should be rewritten from scratch to use this method instead of its 15 layers of tracking + syncing
+                        if (ExtensionsConfigFileGeneratorPlugin.cache === undefined) {
+                            ExtensionsConfigFileGeneratorPlugin.cache = { assets: [], setupFiles: [] };
+                            compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_GenerateConfigFile`, () => {
+                                const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
+                                const blockExtensionsConfig = { metadata: { version: this.version }, scriptHandles: {}, styleHandles: {}, blocks: {}, setupFiles: {} };
+                                for (const assetDataSource of ExtensionsConfigFileGeneratorPlugin.cache?.assets ?? []) {
+                                    const normalizedAssetData = Object.entries(assetDataSource)
+                                        .map(entry => {
+                                        const assetPath = this.extensionsDest && entry[0].startsWith(this.extensionsDest + "/")
+                                            ? entry[0].substring(this.extensionsDest.length + 1) : entry[0];
+                                        return [assetPath, entry[1]];
+                                    });
+                                    for (const [assetPath, assetData] of normalizedAssetData) {
+                                        const match = regex.exec(assetPath);
+                                        if (!match) {
+                                            continue;
+                                        }
+                                        const blockSlug = match[1], assetType = match[2];
+                                        if (blockSlug && assetType) {
+                                            const key = assetType.replace(/-[sm]/gi, chars => chars.substring(1).toUpperCase());
+                                            const handle = `plaudit_block-extension_${blockSlug}-${assetType}`;
+                                            const isCss = assetType.endsWith("tyle");
+                                            blockExtensionsConfig[isCss ? 'styleHandles' : 'scriptHandles'][handle] = {
+                                                src: isCss ? assetPath.replace(/\.js$/, ".css") : assetPath,
+                                                rest: isCss || key.startsWith("editor")
+                                                    ? [assetData.dependencies, assetData.version]
+                                                    : [assetData.dependencies, assetData.version, { strategy: 'defer' }]
+                                            };
+                                            (blockExtensionsConfig.blocks[blockSlug] ?? (blockExtensionsConfig.blocks[blockSlug] = {}))[key] = handle;
+                                        }
+                                    }
+                                    for (const [blockSlug, asset] of ExtensionsConfigFileGeneratorPlugin.cache?.setupFiles ?? []) {
+                                        blockExtensionsConfig.setupFiles[blockSlug] = asset;
+                                    }
+                                }
+                                blockExtensionsConfig.scriptHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.scriptHandles)
+                                    .toSorted(([a], [b]) => a.localeCompare(b)));
+                                blockExtensionsConfig.styleHandles = Object.fromEntries(Object.entries(blockExtensionsConfig.styleHandles)
+                                    .toSorted(([a], [b]) => a.localeCompare(b)));
+                                blockExtensionsConfig.setupFiles = Object.fromEntries(Object.entries(blockExtensionsConfig.setupFiles)
+                                    .toSorted(([a], [b]) => a.localeCompare(b)));
+                                blockExtensionsConfig.blocks = Object.fromEntries(Object.entries(blockExtensionsConfig.blocks)
+                                    .map(block => {
+                                    return [block[0], Object.fromEntries(Object.entries(block[1]).toSorted(([a], [b]) => a.localeCompare(b)))];
+                                })
+                                    .toSorted(([a], [b]) => a.localeCompare(b)));
+                                compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockExtensionsConfig)));
+                            });
+                        }
+                        const myCacheData = { assets: [], setupFiles: [] };
+                        for (const asset of Object.keys(compilation.assets).map(asset => this.stripExtensionsDest(asset))) {
+                            const blockSlug = /^(.+?)-setup.php$/i.exec(asset)?.[1];
+                            if (blockSlug) {
+                                myCacheData.setupFiles.push([blockSlug, asset]);
+                            }
+                        }
+                        const rawAssetDataSource = assets["assets.json"]?.source();
+                        if (typeof rawAssetDataSource !== 'string') {
+                            ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
+                            compilation.errors.push(new Error("assets.json is unexpectedly missing or not a string"));
+                            return;
+                        }
+                        const assetDataSource = JSON.parse(rawAssetDataSource);
+                        if (!(0, shared_1.isRawAssetData)(assetDataSource)) {
+                            ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
+                            compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
+                            return;
+                        }
+                        myCacheData.assets.push(assetDataSource);
+                        compilation.deleteAsset("assets.json");
+                        ExtensionsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myCacheData);
+                        ExtensionsConfigFileGeneratorPlugin.cache = (await ExtensionsConfigFileGeneratorPlugin.semaphore.wait())
+                            .reduce((main, { assets, setupFiles }) => {
+                            main.assets.push(...assets);
+                            main.setupFiles.push(...setupFiles);
+                            return main;
+                        }, { assets: [], setupFiles: [] });
+                    }
+                    catch (e) {
+                        ExtensionsConfigFileGeneratorPlugin.semaphore.reject(this.id);
+                        if (e instanceof Error) {
+                            compilation.errors.push(e);
+                            return;
+                        }
+                        throw e;
+                    }
+                });
+            });
+        }
+        else {
+            compiler.hooks.thisCompilation.tap(this.constructor.name, compilation => {
+                compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_AfterProcessAssets`, this.makeVersionOneAfterProcessAssets(compilation));
+            });
+        }
+    }
+    makeVersionOneAfterProcessAssets(compilation) {
+        return compilationAssets => {
+            const regex = /^(.+?)-((?:editor-|view-|)(?:style|script|script-module))\.(?:css|m?js)$/i;
+            const mapping = {};
+            for (const asset of Object.keys(compilationAssets)) {
+                let match;
+                if ((match = /^(.+?)-setup.php$/i.exec(asset)) && match[1]) {
+                    (mapping[match[1]] ?? (mapping[match[1]] = [{}]))[1] = `${asset}`;
+                }
+                else if ((match = regex.exec(asset)) && match[1] && match[2]) {
+                    const resourceInfo = (mapping[match[1]] ?? (mapping[match[1]] = [{}]))[0];
+                    const key = match[2].replace(/-[sm]/gi, chars => chars.substring(1).toUpperCase());
+                    (resourceInfo[key] ?? (resourceInfo[key] = [])).push([`plaudit_block-extension_${match[1]}-${match[2]}`, asset]);
+                }
+            }
+            compilation.emitAsset(node_path_1.default.join(this.extensionsDest, "mapping.config"), new webpack_1.sources.RawSource((0, php_serializer_1.phpSerialize)(mapping)));
+        };
+    }
+    stripExtensionsDest(item) {
+        return this.extensionsDest && item.startsWith(this.extensionsDest + "/") ? item.substring(this.extensionsDest.length + 1 /* we also need to drop the "/" */) : item;
+    }
+}
+exports.ExtensionsConfigFileGeneratorPlugin = ExtensionsConfigFileGeneratorPlugin;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.d.ts

@@ -0,0 +1,24 @@
+import { UsageLocations } from "../shared";
+import { PHPWriter } from "../utils/php-writer";
+import { type Compiler, type WebpackPluginInstance } from "webpack";
+export declare class PlainEntrypointsConfigFileGeneratorPlugin implements WebpackPluginInstance {
+    private readonly buildRoot;
+    private readonly outputDir;
+    private readonly usageLocations;
+    private readonly handlePrefix;
+    private static readonly semaphore;
+    private static cache?;
+    private readonly id;
+    constructor(buildRoot: string, outputDir: string, usageLocations: UsageLocations, handlePrefix: string);
+    apply(compiler: Compiler): void;
+    private static afterProcessAssets;
+    private static getEmitPath;
+    private static addHandlesToHandleLists;
+    private static appendEnqueuingHandleLists;
+    private static separateHandleListByPriority;
+    /**
+     * 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
+     */
+    static emitResolveBaseUriFunction(writer: PHPWriter): void;
+}
+export declare function kebabCase(value: string): string;

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlainEntrypointsConfigFileGeneratorPlugin = void 0;
+exports.kebabCase = kebabCase;
+const node_path_1 = __importDefault(require("node:path"));
+const shared_1 = require("../shared");
+const php_writer_1 = require("../utils/php-writer");
+const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
+const webpack_1 = require("webpack");
+class PlainEntrypointsConfigFileGeneratorPlugin {
+    buildRoot;
+    outputDir;
+    usageLocations;
+    handlePrefix;
+    static semaphore = new pseduo_semaphore_1.PseudoSemaphore([]);
+    static cache = undefined;
+    id;
+    constructor(buildRoot, outputDir, usageLocations, handlePrefix) {
+        this.buildRoot = buildRoot;
+        this.outputDir = outputDir;
+        this.usageLocations = usageLocations;
+        this.handlePrefix = handlePrefix;
+        this.id = Math.random().toString();
+        PlainEntrypointsConfigFileGeneratorPlugin.semaphore.register(this.id);
+    }
+    apply(compiler) {
+        const tapName = { name: `${this.constructor.name}_ProcessPlainEntrypointFiles`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_REPORT };
+        compiler.hooks.compilation.tap(this.constructor.name, compilation => {
+            PlainEntrypointsConfigFileGeneratorPlugin.cache = undefined;
+            PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reset(this.id);
+            compilation.hooks.processAssets.tapPromise(tapName, async (assets) => {
+                try {
+                    const emitDir = node_path_1.default.join(this.buildRoot, this.outputDir);
+                    if (PlainEntrypointsConfigFileGeneratorPlugin.cache === undefined) {
+                        PlainEntrypointsConfigFileGeneratorPlugin.cache = { assets: [] };
+                        compilation.hooks.afterProcessAssets.tap(`${this.constructor.name}_CompileLoader`, () => {
+                            PlainEntrypointsConfigFileGeneratorPlugin.afterProcessAssets(compilation, emitDir);
+                        });
+                    }
+                    const rawAssetDataSource = assets["assets.json"]?.source();
+                    if (typeof rawAssetDataSource !== 'string') {
+                        PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reject(this.id);
+                        compilation.errors.push(new Error("assets.json is unexpectedly missing or not a string"));
+                        return;
+                    }
+                    const assetDataSource = JSON.parse(rawAssetDataSource);
+                    if (!(0, shared_1.isRawAssetData)(assetDataSource)) {
+                        PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reject(this.id);
+                        compilation.errors.push(new Error("assets.json is does not match the RawAssetData format"));
+                        return;
+                    }
+                    const isScriptRegex = /\.m?[jt]sx?(\?|$)/i;
+                    const myAssetHandles = [];
+                    for (const entrypoint of compilation.entrypoints.values()) {
+                        const srcPath = entrypoint.origins.map(origin => origin.request)[0];
+                        if (!srcPath) {
+                            continue;
+                        }
+                        const entrypointChunk = entrypoint.getEntrypointChunk();
+                        const assetData = entrypointChunk.files.values()
+                            .map(file => assetDataSource[file]).find(v => v !== undefined);
+                        if (!assetData) {
+                            continue;
+                        }
+                        const handles = [];
+                        const entrypointChunkIsScript = isScriptRegex.test(srcPath);
+                        const chunkFiles = entrypoint.chunks.flatMap(chunk => {
+                            return [...chunk.files].filter(file => entrypointChunkIsScript || !isScriptRegex.test(file))
+                                .map(file => [file, chunk === entrypointChunk]);
+                        });
+                        if (chunkFiles.length === 1) {
+                            chunkFiles[0][1] = true;
+                        }
+                        for (const [file, useHandleName] of chunkFiles) {
+                            const isScript = file.toLowerCase().endsWith(".js");
+                            const dependencies = isScript === entrypointChunkIsScript ? assetData.dependencies : [];
+                            const rest = isScript && this.usageLocations.registerScriptArgs !== undefined
+                                ? [dependencies, assetData.version, this.usageLocations.registerScriptArgs] : [dependencies, assetData.version];
+                            const destPath = node_path_1.default.join(compilation.outputOptions.path, file);
+                            handles.push({
+                                src: destPath,
+                                rest,
+                                locations: this.usageLocations,
+                                isScript,
+                                handleName: useHandleName ? this.usageLocations.handle : undefined
+                            });
+                        }
+                        myAssetHandles.push({
+                            handles,
+                            usageLocations: this.usageLocations,
+                            handlePrefix: this.handlePrefix
+                        });
+                    }
+                    compilation.deleteAsset("assets.json");
+                    PlainEntrypointsConfigFileGeneratorPlugin.semaphore.resolve(this.id, myAssetHandles);
+                    PlainEntrypointsConfigFileGeneratorPlugin.cache.assets = (await PlainEntrypointsConfigFileGeneratorPlugin.semaphore.wait()).flat();
+                }
+                catch (e) {
+                    PlainEntrypointsConfigFileGeneratorPlugin.semaphore.reject(this.id);
+                    throw e;
+                }
+            });
+        });
+    }
+    static afterProcessAssets(compilation, emitDir) {
+        //TODO: Add support for editorStyles via the 'block_editor_settings_all' filter
+        const handleLists = {
+            register: [],
+            clientView: [],
+            clientEditor: [],
+            admin: [],
+            login: [],
+            customizer: [],
+            analytics: []
+        };
+        const plainEntrypointsConfig = { scriptHandles: {}, styleHandles: {} };
+        for (const { handles, handlePrefix } of PlainEntrypointsConfigFileGeneratorPlugin.cache?.assets ?? []) {
+            for (const { src, rest, locations, isScript, handleName } of handles) {
+                const finalHandleName = handleName || `${handlePrefix}.${kebabCase(node_path_1.default.basename(src))}`;
+                plainEntrypointsConfig[isScript ? 'scriptHandles' : 'styleHandles'][finalHandleName] = {
+                    src,
+                    rest,
+                    locations,
+                    isScript
+                };
+            }
+        }
+        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('script', Object.entries(plainEntrypointsConfig.scriptHandles)
+            .toSorted(([a], [b]) => a.localeCompare(b)), handleLists);
+        const sortedStyleHandles = Object.entries(plainEntrypointsConfig.styleHandles)
+            .toSorted(([a], [b]) => a.localeCompare(b));
+        PlainEntrypointsConfigFileGeneratorPlugin.addHandlesToHandleLists('style', sortedStyleHandles, handleLists);
+        //TODO: Do we want to sort by type first? Pro: all calls of the same type are together; Con: not all calls for the same block will be together
+        const callItemSorter = (a, b) => /*a.type.localeCompare(b.type) || */ a.handle.localeCompare(b.handle);
+        for (const list of Object.values(handleLists)) {
+            list.sort(callItemSorter);
+        }
+        const writer = new php_writer_1.PHPWriter();
+        if (handleLists.register.length > 0) {
+            PlainEntrypointsConfigFileGeneratorPlugin.emitResolveBaseUriFunction(writer);
+            for (const [priority, prioritizedHandleList] of PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByPriority(handleLists.register)) {
+                writer.action("init", writer => {
+                    writer.call("plaudit_webpack_extensions__resolve_base_uri", [], { assignTo: "$base_uri" });
+                    for (const { handle, type, data } of prioritizedHandleList) {
+                        writer.call(`wp_register_${type}`, [handle, new php_writer_1.Expr(`$base_uri.${php_writer_1.Expr.jsonToPHPConverter(node_path_1.default.relative(emitDir, data.src))}`), ...data.rest]);
+                    }
+                }, { priority });
+            }
+            const sortedEditorStyleHandles = sortedStyleHandles
+                .filter(([_, { locations: { clientEditor }, isScript }]) => !isScript && (clientEditor || typeof clientEditor === 'number'))
+                .map(info => info[1]);
+            if (sortedEditorStyleHandles.length > 0) {
+                writer.linebreak();
+                const themePath = process.cwd();
+                for (const handleData of sortedEditorStyleHandles) {
+                    const handlePath = node_path_1.default.relative(themePath, handleData.src);
+                    writer.call("add_editor_style", [(0, shared_1.leadingSlashIt)(handlePath)]);
+                }
+            }
+        }
+        PlainEntrypointsConfigFileGeneratorPlugin.appendEnqueuingHandleLists(writer, handleLists);
+        const assetPath = PlainEntrypointsConfigFileGeneratorPlugin.getEmitPath(compilation, emitDir);
+        writer.emitAsset(compilation, assetPath);
+    }
+    static getEmitPath(compilation, emitDir) {
+        return node_path_1.default.relative(compilation.outputOptions.path ?? process.cwd(), node_path_1.default.join(emitDir, "plain-entrypoints-loader.php"));
+    }
+    static addHandlesToHandleLists(type, handles, handleLists) {
+        for (const [handle, data] of handles) {
+            if (data.locations.register !== false) {
+                handleLists.register.push({ handle, type, data, priority: typeof data.locations.register === 'number' ? data.locations.register : 10 });
+            }
+            for (const location of shared_1.standardLocationNames) {
+                if (location === 'clientEditor' && type === 'style') {
+                    // We don't include editor styles in the handle list because editor styles are enqueued via a completely separate mechanism at runtime and, therefore,
+                    // cannot be handled by the same code as every other enqueueable item
+                    continue;
+                }
+                if (typeof data.locations[location] === 'number') {
+                    handleLists[location].push({ handle, type, priority: data.locations[location] });
+                }
+                else if (data.locations[location]) {
+                    handleLists[location].push({ handle, type, priority: 10 });
+                }
+            }
+        }
+    }
+    static appendEnqueuingHandleLists(writer, handleLists) {
+        const enqueuingHandleActions = [
+            ["wp_enqueue_scripts", handleLists.clientView], ["enqueue_block_editor_assets", handleLists.clientEditor], ["admin_enqueue_scripts", handleLists.admin],
+            ["login_enqueue_scripts", handleLists.login], ["customize_controls_enqueue_scripts", handleLists.customizer], ["plaudit_enqueue_analytics", handleLists.analytics]
+        ];
+        for (const [action, handleList] of enqueuingHandleActions) {
+            if (handleList.length > 0) {
+                for (const [priority, prioritizedHandleList] of PlainEntrypointsConfigFileGeneratorPlugin.separateHandleListByPriority(handleList)) {
+                    writer.action(action, () => {
+                        for (const handle of prioritizedHandleList) {
+                            writer.call(`wp_enqueue_${handle.type}`, [handle.handle]);
+                        }
+                    }, { priority });
+                }
+            }
+        }
+    }
+    static separateHandleListByPriority(handleItems) {
+        const lists = new Map();
+        for (const handleItem of handleItems) {
+            const list = lists.get(handleItem.priority);
+            if (list) {
+                list.push(handleItem);
+            }
+            else {
+                lists.set(handleItem.priority, [handleItem]);
+            }
+        }
+        return lists.entries().toArray().sort((a, b) => a[0] - b[0]);
+    }
+    /**
+     * 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
+     */
+    static emitResolveBaseUriFunction(writer) {
+        writer.function("plaudit_webpack_extensions__resolve_base_uri", [], () => {
+            writer
+                .static("$base_uri", { withTest: 'chainable' })
+                .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), '/');")
+                .else()
+                .call("error_log", ["UNABLE TO FIGURE OUT WHAT THE RELATIVE PATH TO THE BUILT FILES DIRECTORY SHOULD BE"])
+                .append("$path = '';")
+                .endIf()
+                .append("return $base_uri = trailingslashit(home_url($path));");
+        }, { returnType: "string", includeExistenceCheck: true });
+    }
+}
+exports.PlainEntrypointsConfigFileGeneratorPlugin = PlainEntrypointsConfigFileGeneratorPlugin;
+function kebabCase(value) {
+    const kebabCaseRegexes = [[/([a-z])([A-Z])/g, "$1-$2"], [/[\s_.\-]+/g, "-"]];
+    return kebabCaseRegexes.reduce((str, [pattern, replacement]) => str.replace(pattern, replacement), value).toLowerCase();
+}