@plaudit/webpack-extensions 3.16.0 → 3.17.0

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

@@ -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

@@ -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>;
+}