@plaudit/webpack-extensions 3.15.1 → 3.17.0

package/dist/shared.js

@@ -28,7 +28,6 @@ exports.determineCurrentSourceType = determineCurrentSourceType;
 exports.applyStandards = applyStandards;
 exports.resolveStandard = resolveStandard;
 exports.convertUsageLocationsHandleToEmittableHandle = convertUsageLocationsHandleToEmittableHandle;
-exports.convertUsageLocationsHandleToEmittableHandleSuffix = convertUsageLocationsHandleToEmittableHandleSuffix;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.convertEntrypointFieldForAssetType = convertEntrypointFieldForAssetType;
 exports.leadingSlashIt = leadingSlashIt;
@@ -55,6 +54,7 @@ exports.appendAddInlineAssetCall = appendAddInlineAssetCall;
 exports.wrapInlineAssetContents = wrapInlineAssetContents;
 exports.synchronousDirIterator = synchronousDirIterator;
 exports.instanceOfNodeError = instanceOfNodeError;
+exports.shouldBeSkipped = shouldBeSkipped;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
@@ -86,7 +86,7 @@ exports.standardLocationNamesMeta = {
     analytics: { action: "plaudit_enqueue_analytics" },
 };
 function isStandardLocationName(name) {
-    return name in exports.standardLocationNamesMeta;
+    return Object.hasOwn(exports.standardLocationNamesMeta, name);
 }
 function isRegisterScriptArgsShorthandName(name) {
     return ['lazy', 'eager', 'inline'].includes(name);
@@ -145,37 +145,23 @@ function resolveStandard(standard) {
             return undefined;
     }
 }
-function convertUsageLocationsHandleToEmittableHandle(handle, handlePrefix, generatedNiceName) {
+function convertUsageLocationsHandleToEmittableHandle(handle, handlePrefix, handleSuffix) {
+    const generatedHandle = `${handlePrefix}/${handleSuffix}`;
     let emittableHandle;
     if (!handle) {
-        return `${handlePrefix}/${generatedNiceName}`;
+        return generatedHandle;
     }
     if (typeof handle === 'string') {
         emittableHandle = handle;
     }
     else if (typeof handle === 'function') {
-        emittableHandle = handle(`${handlePrefix}/${generatedNiceName}`);
+        emittableHandle = handle(generatedHandle);
     }
     else {
-        emittableHandle = `${handlePrefix}/${handle.niceName}`;
+        emittableHandle = handle.niceName && `${handlePrefix}/${handle.niceName}`;
     }
-    return emittableHandle.replaceAll("{basename}", generatedNiceName);
-}
-function convertUsageLocationsHandleToEmittableHandleSuffix(handle, generatedNiceName) {
-    let emittableHandle;
-    if (!handle) {
-        return generatedNiceName;
-    }
-    if (typeof handle === 'string') {
-        emittableHandle = handle;
-    }
-    else if (typeof handle === 'function') {
-        emittableHandle = handle(generatedNiceName);
-    }
-    else {
-        emittableHandle = handle.niceName;
-    }
-    return emittableHandle.replaceAll("{basename}", generatedNiceName);
+    // A callback is free to return nothing, which means "use the handle you would have generated"
+    return emittableHandle ? emittableHandle.replaceAll("{basename}", handleSuffix) : generatedHandle;
 }
 function makeEmittableConfigPHP(data, asFullFile, parentIndent = "") {
     const prettyPrintedMetadata = php_writer_1.json2php.make({ indent: "\t", linebreak: "\n", shortArraySyntax: true })(data, parentIndent)
@@ -312,18 +298,10 @@ function emitResolveBaseUriFunction(writer) {
 }
 function getAssetsJson(compilation) {
     const asset = compilation.getAsset("assets.json");
-    if (!asset) {
-        throw new Error("assets.json is unexpectedly missing");
-    }
-    if (isParsedAssetsJson(asset.info["parsed-assets-json"])) {
+    if (asset && isParsedAssetsJson(asset.info["parsed-assets-json"])) {
         return asset.info["parsed-assets-json"];
     }
-    const parsedAssetJson = JSON.parse(asset.source.source().toString('utf-8'));
-    if (!isParsedAssetsJson(parsedAssetJson)) {
-        throw new Error("assets.json is does not match the RawAssetData format");
-    }
-    compilation.updateAsset("assets.json", s => s, a => ({ ...a, "parsed-assets-json": parsedAssetJson }));
-    return parsedAssetJson;
+    throw new Error("assets.json is unexpectedly missing");
 }
 function getParsedAssetsJsonDataForEntrypoint(compilation, entrypoint, metadata) {
     const dest = metadata.dest;
@@ -363,13 +341,24 @@ function emitPHPWriterAsAsset(writer, compilation, file, assetInfo) {
     const contents = writer.toString() + "\n";
     compilation[file in compilation.assets ? 'updateAsset' : 'emitAsset'](file, new webpack_1.sources.RawSource(contents), { size: Buffer.byteLength(contents), ...assetInfo });
 }
-function dedent(text) {
-    const actualText = text.join("\n");
-    const firstLineIndent = actualText.split("\r?\n").find(line => line.length > 0)?.match(/^\s+/)?.[0];
-    if (!firstLineIndent) {
-        return actualText;
-    }
-    return actualText.replaceAll(new RegExp("^" + firstLineIndent, 'mg'), "").replace(/\n{2}$/, "\n");
+function dedent(text, ...values) {
+    const lines = text.reduce((result, part, i) => result + String(values[i - 1]) + part).split(/\r?\n/);
+    // A template that opens and closes on its own line frames the content with two throwaway lines
+    if (lines[0]?.trim() === "") {
+        lines.shift();
+    }
+    if (lines.length > 1 && lines.at(-1)?.trim() === "") {
+        lines.pop();
+    }
+    // Only the lines with content get a say in the indent, and a line break must never count as one
+    const indent = lines.filter(line => line.trim() !== "")
+        .reduce((shortest, line) => {
+        const lineIndent = /^[ \t]*/.exec(line)?.[0] ?? "";
+        return shortest === undefined || lineIndent.length < shortest.length ? lineIndent : shortest;
+    }, undefined);
+    return indent
+        ? lines.map(line => line.startsWith(indent) ? line.substring(indent.length) : line).join("\n")
+        : lines.join("\n");
 }
 function resolveLegacyBlockScriptsInFolder(folder) {
     const blockScriptEntrypoints = [];
@@ -432,3 +421,9 @@ function* synchronousDirIterator(dirPath) {
 function instanceOfNodeError(value, errorType) {
     return !!value && value instanceof errorType;
 }
+/**
+ * This tests if the name starts with a "~", is equal to "example" or "examples", or includes "example" as a name segment
+ */
+function shouldBeSkipped(name) {
+    return name.startsWith("~") || name === "example" || name === "examples" || name.startsWith("example.") || name.includes(".example.");
+}

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

@@ -126,7 +126,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
         const seenExplicitHandles = { scriptHandles: {}, styleHandles: {}, scriptModuleHandles: {} };
         const loadingEntrypoints = [];
         for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
-            if (!dirent.isDirectory() || dirent.name.startsWith("~")) {
+            if (!dirent.isDirectory() || (0, shared_1.shouldBeSkipped)(dirent.name)) {
                 continue;
             }
             const dir = joinPossiblyAbsolutePaths(srcRoot, dirent.name);
@@ -243,8 +243,10 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                     const resolvedBlockEntrypoints = presentEntrypoints
                         .map(presentEntrypoint => {
                         const overallSource = (0, node_path_1.dirname)(blockJsonOrigin);
-                        const overallSourceRelativeName = (0, node_path_1.relative)(overallSource, (0, node_path_1.normalize)((0, node_path_1.join)(blockJsonOrigin, (0, node_path_1.relative)(overallSource, presentEntrypoint.extensionlessExpectedSrc))));
-                        const handleSuffix = (0, shared_1.convertUsageLocationsHandleToEmittableHandleSuffix)(dest.locations.handle, overallSourceRelativeName);
+                        // The handle suffix is the asset's extensionless name relative to its own block, so it
+                        // has to come off the real on-disk path rather than the destination-relative expected src.
+                        const parsedAbsoluteSrc = (0, node_path_1.parse)(presentEntrypoint.absoluteSrc);
+                        const overallSourceRelativeName = (0, node_path_1.normalize)((0, node_path_1.join)((0, node_path_1.relative)(overallSource, parsedAbsoluteSrc.dir), parsedAbsoluteSrc.name));
                         const handleGroup = (0, shared_1.getHandleGroup)(presentEntrypoint.entrypointField);
                         let explicitlySetHandle;
                         if (presentEntrypoint.handle) {
@@ -265,8 +267,9 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         else {
                             explicitlySetHandle = undefined;
                         }
+                        const emittableHandle = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, handlePrefix, explicitlySetHandle ? explicitlySetHandle.substring(handlePrefix.length + 1) : overallSourceRelativeName);
                         if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
-                            return { blockJsonOrigin, ...presentEntrypoint, handle: explicitlySetHandle ?? `${handlePrefix}/${handleSuffix}`, dest, handleGroup };
+                            return { blockJsonOrigin, ...presentEntrypoint, handle: emittableHandle, dest, handleGroup };
                         }
                         const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
                         let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
@@ -281,7 +284,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             ...presentEntrypoint,
                             entrypointName: deduplicatedEntrypointName,
                             extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: explicitlySetHandle ?? `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`,
+                            handle: emittableHandle,
                             handleGroup,
                             dest
                         };
@@ -304,15 +307,15 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         const packageJsonOrigin = (0, node_path_1.join)(dir, 'package.json');
                         const packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonOrigin, 'utf8'));
                         if (packageJson['main']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, commonConfig.scriptExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, s => commonConfig.scriptExtension.test(s), { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
                         if (!processingModules && packageJson['style']) {
-                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, shared_1.styleExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
+                            rawEntrypoints.push(...mapToRealEntrypoints(packageJson['style'], dir, s => shared_1.styleExtension.test(s), { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
                     }
                     catch (e) {
                         try {
-                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || shared_1.styleExtension.test(ep)));
+                            rawEntrypoints.push(...parseEntrypointsJSON(dir, dest, ep => commonConfig.scriptExtension.test(ep) || (!processingModules && shared_1.styleExtension.test(ep))));
                         }
                         catch (e) {
                             // This just means that the directory doesn't contain any declared entrypoints.

package/dist/utils/css-writer.js

@@ -9,7 +9,7 @@ function convertToCSS(writableCSSObject, pretty = true) {
         return convertToCSSPretty(writableCSSObject, "");
     }
     else {
-        return convertToCSS(writableCSSObject);
+        return convertToCSSUgly(writableCSSObject);
     }
 }
 function convertToCSSPretty(writableCSSObject, indentation) {
@@ -23,7 +23,7 @@ function convertToCSSPretty(writableCSSObject, indentation) {
         }
         else {
             res += " {\n";
-            res += convertToCSSPretty(writableCSSObject, indentation + "\t");
+            res += convertToCSSPretty(value, indentation + "\t");
             res += indentation + "}\n";
         }
     }
@@ -39,7 +39,7 @@ function convertToCSSUgly(writableCSSObject) {
             res += `:${value};`;
         }
         else {
-            res += "{" + convertToCSSUgly(writableCSSObject) + "}";
+            res += "{" + convertToCSSUgly(value) + "}";
         }
     }
     return res;

package/dist/utils/entrypoint-resolution-logic.d.ts

@@ -1,10 +1,13 @@
-import { type AdvancedOutputConfig, type PlauditWordpressWebpackConfig } from "../shared";
+import { type AdvancedOutputConfig, type PathQueryParameters, type PlauditWordpressWebpackConfig } from "../shared";
 export declare const enum SourceType {
     blocks = "blocks",
     extensions = "extensions",
     plain = "plain"
 }
 export declare function isSourceType(str: string): str is SourceType;
-type Entrypoints = [string, AdvancedOutputConfig][];
+type ResolvedSourceConfig = AdvancedOutputConfig & {
+    pathQueryParameters?: PathQueryParameters;
+};
+type Entrypoints = [string, ResolvedSourceConfig][];
 export declare function resolveAllConfigLevelEntrypoints(config: PlauditWordpressWebpackConfig, projectRoot?: string): Record<'staticEntrypoints' | 'dynamicEntrypoints', Entrypoints>;
 export {};

package/dist/utils/location-encoding-filename-parser.d.ts

@@ -10,7 +10,6 @@ export type ParsedLocationEncodingFilename = {
         };
     };
     flags: NormalizedEnqueuingControlFlags;
-    niceName?: string;
 };
 export declare function parseLocationEncodingFilename(filename: string): ParsedLocationEncodingFilename | undefined;
 export declare function parseLocationEncodingFilenameForBlock(filename: string, errorBuilder?: (message: string, filename: string) => unknown): (Omit<ParsedLocationEncodingFilename, 'locations'> & {

package/dist/utils/location-encoding-filename-parser.js

@@ -7,7 +7,7 @@ const node_path_1 = require("node:path");
 const shared_1 = require("../shared");
 function parseLocationEncodingFilename(filename) {
     const { name, ext } = (0, node_path_1.parse)(filename);
-    if (name.startsWith("~")) {
+    if ((0, shared_1.shouldBeSkipped)(name)) {
         return undefined;
     }
     let type = /^\.(?:s[ac]|p?c)ss$/i.test(ext) ? 'style' : /^\.m[jt]sx?/i.test(ext) ? 'script-module' : /^\.[jt]sx?/i.test(ext) ? 'script' : false;
@@ -79,16 +79,17 @@ function parseLocationEncodingFilename(filename) {
         return undefined;
     }
     if (niceName !== undefined) {
-        locations.handle = { niceName };
+        // We need to kebab-case the nice name value for web-safety
+        locations.handle = { niceName: (0, shared_1.kebabCase)(niceName) };
     }
-    return { type, locations, flags, niceName };
+    return { type, locations, flags };
 }
 function parseLocationEncodingFilenameForBlock(filename, errorBuilder = shared_1.newWebpackErrorForFile) {
     const parsedFilename = parseLocationEncodingFilename(filename);
     if (parsedFilename !== undefined) {
         const { handle, ...locations } = parsedFilename.locations;
         if ((0, shared_1.constantKeys)(locations).some(value => value !== 'clientView' && value !== 'clientEditor')) {
-            throw errorBuilder(`Block assets cannot be enqueued anywhere other than view, editor, or both. Saw: ${(0, shared_1.constantKeys)(parsedFilename).join(", ")}`, filename);
+            throw errorBuilder(`Block assets cannot be enqueued anywhere other than view, editor, or both. Saw: ${(0, shared_1.constantKeys)(parsedFilename.locations).join(", ")}`, filename);
         }
         if (Object.values(locations).some(value => typeof value === 'number')) {
             throw errorBuilder(`Block assets cannot be enqueued with a priority`, filename);

package/dist/utils/path-query-and-related-helpers.d.ts

@@ -15,7 +15,6 @@ export declare function unpackPotentiallyPrefixedFilePath(filePath: string): [st
  */
 export declare function unpackPathQuery(pathQuery: string): PathQueryParameters | undefined;
 export type LoadingStrategy = boolean | 'defer' | 'async' | 'eager' | 'lazy' | 'inline';
-export declare function isValidLoadingStrategy(strategy: any): strategy is LoadingStrategy | undefined;
 export declare function newInvalidLoadingStrategyError(strategy: unknown, file: string): import("webpack").WebpackError;
 export type InFooter = boolean;
 export declare function isValidInFooter(in_footer: unknown): in_footer is InFooter;

package/dist/utils/path-query-and-related-helpers.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAssetFileContents = getAssetFileContents;
 exports.unpackPotentiallyPrefixedFilePath = unpackPotentiallyPrefixedFilePath;
 exports.unpackPathQuery = unpackPathQuery;
-exports.isValidLoadingStrategy = isValidLoadingStrategy;
 exports.newInvalidLoadingStrategyError = newInvalidLoadingStrategyError;
 exports.isValidInFooter = isValidInFooter;
 exports.newInvalidInFooterError = newInvalidInFooterError;
@@ -78,9 +77,6 @@ function unpackPathQuery(pathQuery) {
     }, {});
 }
 const namedStrategies = ['defer', 'async', 'eager', 'lazy', 'inline'];
-function isValidLoadingStrategy(strategy) {
-    return strategy === undefined || (typeof strategy === 'string' && namedStrategies.includes(strategy));
-}
 function newInvalidLoadingStrategyError(strategy, file) {
     return (0, shared_1.newWebpackErrorForFile)(`The strategy was invalid. Received: ${strategy}, Expected: undefined|boolean|'${namedStrategies.join("'|'")}'`, file);
 }

package/dist/wordpress-ports/dependency-extraction-webpack-plugin/index.d.ts

@@ -0,0 +1,72 @@
+import LegacyDependencyExtractionWebpackPlugin from "@wordpress/dependency-extraction-webpack-plugin";
+import { Compilation, Compiler, Module, type TemplatePath } from "webpack";
+export interface EnhancedDependencyExtractionWebpackPluginOptions {
+    injectPolyfill?: boolean;
+    useDefaults?: boolean;
+    outputFilename?: TemplatePath;
+    requestToExternal?: (request: string) => string | string[] | undefined;
+    requestToExternalModule?: (request: string) => string | boolean | undefined;
+    requestToHandle?: (request: string) => string | undefined;
+    requestToScriptModule?: (request: string) => string | boolean | Error | undefined;
+    externalizedReport?: string | boolean;
+}
+export declare class EnhancedDependencyExtractionWebpackPlugin {
+    /**
+     * Track requests that are externalized.
+     *
+     * Because we don't have a closed set of dependencies, we need to track what has
+     * been externalized so we can recognize them in a later phase when the dependency
+     * lists are generated.
+     */
+    private readonly externalizedDeps;
+    private readonly options;
+    /**
+     * Track requests that a script build externalizes as script modules.
+     *
+     * These can only be reached through a runtime `import()`, which requires
+     * support for dynamic import in the output environment. The set is used
+     * to report an actionable error when that support is missing.
+     */
+    private readonly scriptModuleDepsInScript;
+    /**
+     * Whether we should use modules. This will be set later to match webpack's `output.module` option.
+     */
+    private useModules;
+    constructor(options: EnhancedDependencyExtractionWebpackPluginOptions | LegacyDependencyExtractionWebpackPlugin | EnhancedDependencyExtractionWebpackPlugin);
+    /**
+     * Convert a script module request to an external suitable for a script
+     * build.
+     *
+     * A classic script cannot contain a static `import`, so the `module`
+     * external type is not usable here: the script module has to be reached
+     * through a runtime `import()`, which is the `import` external type. The
+     * bare specifier is resolved by the import map that WordPress prints for
+     * enqueued script modules.
+     *
+     * @param {string}                request  Original module request.
+     * @param {string|boolean|Error=} external Result of a script module external resolution.
+     * @return {string|undefined} The resulting external definition.
+     */
+    static toScriptModuleExternalInScript(request: string, external?: string | boolean | Error): string | undefined;
+    private readonly externalizeWpDeps;
+    /**
+     * @param {string} request
+     * @return {string} Mapped dependency name
+     */
+    protected mapRequestToDependency(request: string): string;
+    apply(compiler: Compiler): void;
+    /**
+     * Check for magic comments before minification, so minification doesn't have to preserve them.
+     */
+    checkForMagicComments(compilation: Compilation): void;
+    addAssets(compilation: Compilation): void;
+    private static readonly staticDepsCurrent;
+    private static readonly staticDepsCache;
+    /**
+     * Can we trace a line of static dependencies from an entry to a module
+     *
+     * @return {boolean} True if there is a static import path to the root
+     */
+    static hasStaticDependencyPathToRoot(compilation: Compilation, block: Module): boolean;
+    readonly addExternalizedDep: (value: string) => Set<string>;
+}