@plaudit/webpack-extensions 2.55.0 → 2.56.0

package/build/plugins/BlockJSONManagingPlugin.d.ts

@@ -5,8 +5,6 @@ export declare class BlockJSONManagingPlugin implements WebpackPluginInstance {
     private readonly blocksDest;
     static readonly mappableModuleKeys: readonly ["viewScriptModule", "scriptModule"];
     static readonly mappableNonModuleKeys: readonly ["editorScript", "script", "viewScript", "editorStyle", "style", "viewStyle"];
-    private static readonly styleExtensionPattern;
-    private static readonly scriptExtensionPattern;
     private static readonly mappableKeys;
     private static readonly blockJsonToEntrypointsMap;
     private static readonly blockJsonRawDependenciesMap;

package/build/plugins/BlockJSONManagingPlugin.js

@@ -15,8 +15,6 @@ class BlockJSONManagingPlugin {
     blocksDest;
     static mappableModuleKeys = ["viewScriptModule", "scriptModule"];
     static mappableNonModuleKeys = ["editorScript", "script", "viewScript", "editorStyle", "style", "viewStyle"];
-    static styleExtensionPattern = /\.(p?c|sa)ss$/i;
-    static scriptExtensionPattern = /\.m?[tj]sx?$/i;
     static mappableKeys = [...BlockJSONManagingPlugin.mappableNonModuleKeys, ...BlockJSONManagingPlugin.mappableModuleKeys];
     static blockJsonToEntrypointsMap = new Map();
     static blockJsonRawDependenciesMap = new Map();
@@ -178,9 +176,9 @@ class BlockJSONManagingPlugin {
                 const prefix = value.startsWith("./", 5) ? "./" : "";
                 const relativePath = node_path_1.default.relative(node_path_1.default.dirname(name), entryMeta.path);
                 const res = [`file:${prefix}${relativePath}`, entryMeta.hash];
-                if (BlockJSONManagingPlugin.styleExtensionPattern.test(entryMeta.path)) {
+                if (shared_1.styleExtension.test(entryMeta.path)) {
                     return [res,
-                        derivedFiles.filter(derivedFile => !BlockJSONManagingPlugin.scriptExtensionPattern.test(derivedFile))
+                        derivedFiles.filter(derivedFile => !shared_1.scriptExtension.test(derivedFile))
                             .map(derivedFile => `file:./${node_path_1.default.relative(node_path_1.default.dirname(name), derivedFile)}`)
                     ];
                 }

package/build/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -116,10 +116,33 @@ class PlainEntrypointsConfigFileGeneratorPlugin {
             customizer: [],
             analytics: []
         };
+        const allNamedHandles = (PlainEntrypointsConfigFileGeneratorPlugin.cache?.assets ?? [])
+            .flatMap(({ handles }) => handles)
+            .filter((handle) => !!handle.handleName)
+            .sort((a, b) => a.src.localeCompare(b.src));
+        const usedScriptHandleNames = Object.fromEntries(allNamedHandles
+            .filter(handle => handle.isScript)
+            .map(handle => [handle.handleName, handle.src]));
+        const usedStyleHandleNames = Object.fromEntries(allNamedHandles
+            .filter(handle => !handle.isScript)
+            .map(handle => [handle.handleName, handle.src]));
         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))}`;
+                let finalHandleName;
+                if (handleName) {
+                    finalHandleName = handleName;
+                }
+                else {
+                    const basename = node_path_1.default.basename(src).replace(/_(?:script|style)(?:-\d+)?\.(?:css|js)$/, "");
+                    const baseFinalHandleName = `${handlePrefix}.${kebabCase(basename)}`;
+                    const handleNameMap = (isScript ? usedScriptHandleNames : usedStyleHandleNames);
+                    finalHandleName = baseFinalHandleName;
+                    for (let count = 0; finalHandleName in handleNameMap && handleNameMap[finalHandleName] !== src;) {
+                        finalHandleName = `${baseFinalHandleName}-${++count}`;
+                    }
+                    handleNameMap[finalHandleName] = src;
+                }
                 plainEntrypointsConfig[isScript ? 'scriptHandles' : 'styleHandles'][finalHandleName] = {
                     src,
                     rest,

package/build/shared.d.ts

@@ -39,7 +39,7 @@ export type Externals = {
     [dep: string]: IndividualExternalDepConfig;
 };
 export type AdvancedOutputConfig = {
-    destination: string;
+    destination?: string;
     withLegacyBlocksIn?: string | undefined;
     additionalDependencies?: string[];
     directoryLayout?: SourceType;
@@ -48,11 +48,12 @@ export type AdvancedOutputConfig = {
     bundleAnalyzer?: boolean;
     locations?: UsageLocations;
 };
+export type VerifiedAdvancedOutputConfig = Omit<AdvancedOutputConfig, 'destination'> & Required<Pick<AdvancedOutputConfig, 'destination'>>;
 export type PlauditWordpressWebpackConfig = {
     standaloneBlocks?: boolean;
     variables?: Record<string, any>;
     verbose?: boolean;
-    src: string[] | Record<string, string | AdvancedOutputConfig>;
+    src: string[] | Record<string, string | AdvancedOutputConfig | boolean>;
     stats?: Configuration['stats'];
     postcss?: {
         functions?: (variables: (name: string) => unknown) => PostcssFunctionsOptions['functions'];
@@ -67,6 +68,7 @@ export type PlauditWordpressWebpackConfig = {
     plainEntrypointsHandlePrefix?: string;
     plainEntrypointsVersion?: 1 | 2;
     srcDir?: string;
+    srcPrefixes?: string[];
 };
 export declare function makeEmittableConfigPHP(data: any): string;
 export type Sync<V> = {
@@ -85,4 +87,9 @@ export declare class SyncsManager<V> {
     private makeSync;
 }
 export declare function leadingSlashIt(pathOrSomething: string): string;
+export declare const scriptExtension: RegExp;
+export declare const scriptWithoutModuleExtension: RegExp;
+export declare const scriptWithModuleExtension: RegExp;
+export declare const styleExtension: RegExp;
+export declare function scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "" | "script" | "style";
 export {};

package/build/shared.js

@@ -3,11 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncsManager = exports.standardLocationNames = void 0;
+exports.styleExtension = exports.scriptWithModuleExtension = exports.scriptWithoutModuleExtension = exports.scriptExtension = exports.SyncsManager = exports.standardLocationNames = void 0;
 exports.isRawAssetData = isRawAssetData;
 exports.determineCurrentSourceType = determineCurrentSourceType;
 exports.makeEmittableConfigPHP = makeEmittableConfigPHP;
 exports.leadingSlashIt = leadingSlashIt;
+exports.scriptOrStyleTest = scriptOrStyleTest;
 const json_to_php_but_with____injection_1 = __importDefault(require("./utils/json-to-php-but-with-__-injection"));
 function isRawAssetData(thing) {
     if (!thing || typeof thing !== 'object') {
@@ -70,3 +71,10 @@ exports.SyncsManager = SyncsManager;
 function leadingSlashIt(pathOrSomething) {
     return pathOrSomething.startsWith('/') ? pathOrSomething : ('/' + pathOrSomething);
 }
+exports.scriptExtension = /(?<filename>.+)(?<extension>\.m?[jt]sx?)$/i;
+exports.scriptWithoutModuleExtension = /(?<filename>.+)(?<extension>\.[jt]sx?)$/i;
+exports.scriptWithModuleExtension = /(?<filename>.+)(?<extension>\.m[jt]sx?)$/i;
+exports.styleExtension = /(?<filename>.+)(?<extension>\.(p?c|sa)ss)$/i;
+function scriptOrStyleTest(entryPath, scriptExtension) {
+    return scriptExtension.test(entryPath) ? "script" : (exports.styleExtension.test(entryPath) ? "style" : "");
+}

package/build/utils/common-config-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { AdvancedOutputConfig, PlauditWordpressWebpackConfig } from "../shared";
+import { PlauditWordpressWebpackConfig, VerifiedAdvancedOutputConfig } from "../shared";
 import type { Compiler, Configuration, EntryObject, WebpackPluginInstance } from "webpack";
 import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
 export type VerifiedPlauditWordpressWebpackConfig = Required<Omit<PlauditWordpressWebpackConfig, 'variables' | 'src' | 'externals'>> & {
@@ -16,11 +16,7 @@ export type CommonConfigProcessingResult = {
     scriptExtension: RegExp;
     updateCurrentVariables: (value: VerifiedPlauditWordpressWebpackConfig['currentVariables']) => unknown;
 };
-export declare const scriptWithoutModuleExtension: RegExp;
-export declare const scriptWithModuleExtension: RegExp;
-export declare const styleExtension: RegExp;
-export declare function scriptOrStyleTest(entryPath: string, scriptExtension: RegExp): "" | "script" | "style";
 export declare function joinPossiblyAbsolutePaths(...paths: (string | undefined)[]): string;
 export declare function groupEntrypointsByAssetFile<T>(entrypoints: T[], entrypointNameExtractor: (t: T) => string): Map<string, T[]>;
-export declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: AdvancedOutputConfig): () => Promise<EntryObject>;
-export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, srcIsDirectory: boolean, dest: string | AdvancedOutputConfig, src: string, srcRoot: string | string[], entry: () => Promise<EntryObject> | EntryObject, plugins: CommonPluginConfig['plugins']): Configuration;
+export declare function resolveEntryFromDirectory(commonConfig: CommonConfigProcessingResult, srcRoot: string, dest: VerifiedAdvancedOutputConfig): () => Promise<EntryObject>;
+export declare function commonMakeWebpackConfig(config: VerifiedPlauditWordpressWebpackConfig, commonConfig: CommonConfigProcessingResult, webpackConfig: Configuration, srcIsDirectory: boolean, dest: VerifiedAdvancedOutputConfig, src: string, srcRoot: string | string[], entry: () => Promise<EntryObject> | EntryObject, plugins: CommonPluginConfig['plugins']): Configuration;

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

@@ -3,23 +3,16 @@ 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 shared_1 = require("../shared");
 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")));
@@ -77,21 +70,21 @@ function parseEntrypointsJSON(dir, dest) {
     }
 }
 function determineEntrypointType(entrypoint, scriptExtension) {
-    let res = scriptOrStyleTest(entrypoint[0], scriptExtension);
+    let res = (0, shared_1.scriptOrStyleTest)(entrypoint[0], scriptExtension);
     if (res) {
         return res;
     }
     if (typeof entrypoint[1] === 'string') {
-        return scriptOrStyleTest(entrypoint[1], scriptExtension);
+        return (0, shared_1.scriptOrStyleTest)(entrypoint[1], scriptExtension);
     }
     else if (Array.isArray(entrypoint[1])) {
-        return entrypoint[1].reduce((prior, ep) => prior || scriptOrStyleTest(ep, scriptExtension), "");
+        return entrypoint[1].reduce((prior, ep) => prior || (0, shared_1.scriptOrStyleTest)(ep, scriptExtension), "");
     }
     else if (typeof entrypoint[1].import === 'string') {
-        return scriptOrStyleTest(entrypoint[1].import, scriptExtension);
+        return (0, shared_1.scriptOrStyleTest)(entrypoint[1].import, scriptExtension);
     }
     else {
-        return entrypoint[1].import.reduce((prior, ep) => prior || scriptOrStyleTest(ep, scriptExtension), "");
+        return entrypoint[1].import.reduce((prior, ep) => prior || (0, shared_1.scriptOrStyleTest)(ep, scriptExtension), "");
     }
 }
 function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
@@ -260,13 +253,13 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, srcIsDirec
     else {
         outputLibrary = webpackConfig.output?.library;
     }
-    const canCopyFiles = srcIsDirectory && src !== dest;
+    const canCopyFiles = srcIsDirectory && src !== dest.destination;
     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,
+                        to: dest.destination,
                         context: srcRoot /* canCopyFiles can only be true if srcRoot is a string, so this is safe  */, noErrorOnMissing: true
                     }]
             })

package/build/utils/php-writer.js

@@ -22,7 +22,7 @@ class Expr {
 exports.Expr = Expr;
 class PHPWriter {
     inlineFirstLine;
-    buffer = "";
+    buffer = [];
     indentation = "";
     printingInPHP = true;
     fileNamespace = "";
@@ -40,7 +40,7 @@ class PHPWriter {
     }
     append(...lines) {
         for (const line of lines) {
-            this.buffer += `\n${this.indentation}${line}`;
+            this.buffer.push(`${this.indentation}${line}`);
         }
         return this;
     }
@@ -57,7 +57,7 @@ class PHPWriter {
         return this;
     }
     linebreak() {
-        this.buffer += '\n';
+        this.buffer.push("");
         return this;
     }
     call(func, args, opts = {}) {
@@ -166,21 +166,25 @@ class PHPWriter {
         return this;
     }
     toString() {
-        let fileContents = "";
+        const fileContents = [];
+        let canInline = true;
         if (this.fileNamespace) {
-            fileContents += `\nnamespace ${this.fileNamespace};\n`;
+            canInline = false;
+            fileContents.push(`namespace ${this.fileNamespace};`);
         }
-        if (this.useList) {
-            for (const use of this.useList.toSorted()) {
-                fileContents += `\nuse ${use};`;
-            }
-            fileContents += "\n";
+        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")}`;
         }
-        if (this.inlineFirstLine && !fileContents) {
-            return `<?php ${this.buffer.trimStart()}`;
+        else if (fileContents.find(line => line.length > 0)) {
+            return "<?php\n" + fileContents.join("\n");
         }
         else {
-            return "<?php" + fileContents + this.buffer;
+            return "<?php";
         }
     }
     emitAsset(compilation, file, assetInfo) {

package/build/wordpress-scripts-wrapper.js

@@ -36,8 +36,10 @@ function resolveLegacyBlockScriptsInFolder(folder) {
     }
     return blockScriptEntrypoints;
 }
-function testForDuplicatedEntryPaths(config) {
-    const seenPaths = (0, common_config_helpers_1.groupEntrypointsByAssetFile)(Array.isArray(config.src) ? config.src : Object.values(config.src).map(bn => typeof bn === 'string' ? bn : bn.destination), bn => bn);
+function testForDuplicatedEntryPaths(sources) {
+    const seenPaths = (0, common_config_helpers_1.groupEntrypointsByAssetFile)(Array.isArray(sources)
+        ? sources.map(s => typeof s === 'string' ? s : s[1].destination)
+        : Object.values(sources).map(bn => typeof bn === 'string' ? bn : bn.destination), bn => bn);
     let projectPrefix = undefined;
     let duplicatedPaths = "";
     for (const sameNamePaths of seenPaths.values()) {
@@ -166,8 +168,15 @@ function injectSupportForInliningSVGsAsStrings(rules) {
     });
 }
 function buildVerifiedConfig(config) {
-    testForDuplicatedEntryPaths(config);
     const { standaloneBlocks = false, stats = 'errors-warnings', variables: rawVariables, verbose = process.argv.includes('--verbose') || process.env['VERBOSE'] === 'true', postcss = {}, externals, assumeGlobalizedPlauditLibraries = true, processTranslationConfigs = true, combineAssetMetadata = true, useWebpackResourceFiltering = true, outputDir = "", extensionsVersion = 1, plainEntrypointsHandlePrefix = "", plainEntrypointsVersion = 1, srcDir = "" } = config;
+    let srcPrefixes;
+    const trailingSlashedSrcDir = srcDir && !srcDir.endsWith("/") ? srcDir + "/" : srcDir;
+    if (config.srcPrefixes === undefined) {
+        srcPrefixes = srcDir ? [trailingSlashedSrcDir] : ["src/"];
+    }
+    else {
+        srcPrefixes = (srcDir && !config.srcPrefixes.includes(trailingSlashedSrcDir) ? [...config.srcPrefixes, trailingSlashedSrcDir] : config.srcPrefixes);
+    }
     if (plainEntrypointsVersion > 1) {
         if (!plainEntrypointsHandlePrefix) {
             throw new Error("Plain Entrypoints V2 and higher require 'plainEntrypointsHandlePrefix' to be set");
@@ -176,6 +185,47 @@ function buildVerifiedConfig(config) {
             throw new Error("Plain Entrypoints V2 and higher require 'outputDir' to be set");
         }
     }
+    const normalizeSrcAndDestination = ([src, dest]) => {
+        if (srcDir) {
+            src = node_path_1.default.join(srcDir, src);
+        }
+        src = node_path_1.default.isAbsolute(src) ? node_path_1.default.relative(process.cwd(), src) : src;
+        if (dest.destination !== undefined && node_path_1.default.isAbsolute(dest.destination)) {
+            dest = { ...dest, destination: node_path_1.default.relative(process.cwd(), dest.destination) };
+        }
+        return [src, dest];
+    };
+    const rawSources = Array.isArray(config.src)
+        ? config.src.map(s => normalizeSrcAndDestination([s, { destination: s }]))
+        : Object.entries(config.src)
+            .map(([k, v]) => {
+            return normalizeSrcAndDestination([k, typeof v === 'boolean' ? {} : (typeof v === 'string' ? { destination: v } : v)]);
+        });
+    // Destination -> source map
+    const allocatedDestinations = {};
+    const partiallyVerifiedSources = rawSources.map(rawSource => {
+        const destination = rawSource[1].destination;
+        if (destination !== undefined) {
+            const effectiveDestination = toEffectiveWebpackDestination(destination);
+            allocatedDestinations[effectiveDestination] = rawSource[0]; // We need to pre-populate the allocatedDestinations map with statically-declared destinations
+            return [rawSource[0], { ...rawSource[1], destination, effectiveDestination, staticallyDeclaredDestination: true }];
+        }
+        else {
+            const naiveDestination = deriveNaiveDestinationFromUnverifiedSourceEntry(rawSource, srcPrefixes);
+            const effectiveDestination = toEffectiveWebpackDestination(naiveDestination);
+            return [rawSource[0], { ...rawSource[1], destination: naiveDestination, effectiveDestination, staticallyDeclaredDestination: false }];
+        }
+    });
+    const dynamicEffectiveDestinationsWithExpectedNaiveDuplicates = partiallyVerifiedSources
+        .filter(entry => !entry[1].staticallyDeclaredDestination)
+        .map(entry => entry[1].effectiveDestination)
+        .reduce((a, dest) => {
+        a[dest] = (a[dest] !== undefined); // If it's undefined, then this is the first instance, otherwise, it's not the first instance and, therefore, is expected to be a duplicate
+        return a;
+    }, {});
+    const sources = partiallyVerifiedSources
+        .map(entry => finalizeEntryDestination(entry, dynamicEffectiveDestinationsWithExpectedNaiveDuplicates, allocatedDestinations));
+    testForDuplicatedEntryPaths(sources);
     let variablesFilePath = undefined;
     const currentVariables = rawVariables ?? {};
     if (!rawVariables) {
@@ -183,22 +233,53 @@ function buildVerifiedConfig(config) {
     }
     const cfg = {
         currentVariables, postcss, standaloneBlocks, stats, variablesFilePath, verbose, externals, assumeGlobalizedPlauditLibraries, processTranslationConfigs, combineAssetMetadata,
-        useWebpackResourceFiltering, outputDir, extensionsVersion, plainEntrypointsVersion, plainEntrypointsHandlePrefix, srcDir
+        useWebpackResourceFiltering, outputDir, extensionsVersion, plainEntrypointsVersion, plainEntrypointsHandlePrefix, srcDir, srcPrefixes
     };
-    const sources = (Array.isArray(config.src) ? config.src.map(s => [s, s]) : Object.entries(config.src))
-        .map(entry => {
-        let dest = typeof entry[1] === 'string' ? { destination: entry[1] } : entry[1];
-        if (srcDir) {
-            return [node_path_1.default.join(srcDir, entry[0]), dest];
-        }
-        const relativeSrc = node_path_1.default.isAbsolute(entry[0]) ? node_path_1.default.relative(process.cwd(), entry[0]) : entry[0];
-        if (node_path_1.default.isAbsolute(dest.destination)) {
-            dest = { ...dest, destination: node_path_1.default.relative(process.cwd(), dest.destination) };
-        }
-        return [relativeSrc, dest];
-    });
     return cfg.outputDir ? { cfg, sources } : withDerivedOutputDir(cfg, sources);
 }
+function toEffectiveWebpackDestination(destination) {
+    const pathParts = node_path_1.default.parse(destination);
+    return node_path_1.default.join(pathParts.dir, pathParts.name);
+}
+function deriveNaiveDestinationFromUnverifiedSourceEntry([src, { destination }], srcPrefixes) {
+    if (destination !== undefined) {
+        return destination;
+    }
+    const commaIndex = src.indexOf(',');
+    const primarySource = stripSrcPrefix(commaIndex > -1 ? src.substring(0, commaIndex).trim() : src, srcPrefixes);
+    const scriptParts = shared_1.scriptExtension.exec(primarySource);
+    if (scriptParts !== null) {
+        return `${scriptParts.groups['filename']}.js`; // filename is always defined here
+    }
+    const styleParts = shared_1.styleExtension.exec(primarySource);
+    if (styleParts !== null) {
+        return `${styleParts.groups['filename']}.css`; // filename is always defined here
+    }
+    return primarySource;
+}
+function stripSrcPrefix(src, srcPrefixes) {
+    const prefix = srcPrefixes.find(sp => src.startsWith(sp));
+    if (!prefix) {
+        return src;
+    }
+    return src[prefix.length] === '/' ? src.substring(prefix.length + 1) : src.substring(prefix.length);
+}
+function finalizeEntryDestination(entry, dynamicEffectiveDestinationsWithExpectedNaiveDuplicates, allocatedDestinations) {
+    if (entry[1].staticallyDeclaredDestination) {
+        return entry;
+    }
+    //TODO: Maybe try to figure out a way to avoid generated handles unnecessarily including "_script" and "_style"
+    const extension = node_path_1.default.extname(entry[1].destination);
+    const filename = dynamicEffectiveDestinationsWithExpectedNaiveDuplicates[entry[1].effectiveDestination]
+        ? entry[1].effectiveDestination + (extension === '.css' ? "_script" : "_style")
+        : entry[1].effectiveDestination;
+    let count = 0, derivedDestination = filename + extension;
+    while (derivedDestination in allocatedDestinations && allocatedDestinations[derivedDestination] !== entry[0]) {
+        derivedDestination = `${filename}_${++count}${extension}`; // We don't want to add deduplication indexes unless absolutely necessary
+    }
+    allocatedDestinations[derivedDestination] = entry[0];
+    return [entry[0], { ...entry[1], destination: derivedDestination }];
+}
 function withDerivedOutputDir(cfg, sources) {
     const destinations = sources.map(([_, { destination }]) => destination.split(/[\/\\]/g));
     if (destinations.length < 2) {
@@ -220,7 +301,7 @@ function withDerivedOutputDir(cfg, sources) {
 function handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins) {
     if (process.env["NO_TS_CHECKER"] !== "true") {
         const include = (Array.isArray(srcRoot) ? srcRoot : [srcRoot])
-            .filter(sr => node_path_1.default.extname(sr).length === 0 || (0, common_config_helpers_1.scriptOrStyleTest)(sr, scriptExtension) === "script")
+            .filter(sr => node_path_1.default.extname(sr).length === 0 || (0, shared_1.scriptOrStyleTest)(sr, scriptExtension) === "script")
             .map(sr => node_path_1.default.extname(sr).length > 0 ? sr : node_path_1.default.join(sr, "**", "*"));
         if (include.length > 0) {
             plugins.push(new fork_ts_checker_webpack_plugin_1.default({
@@ -264,7 +345,7 @@ function buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest,
     })
         ?? [];
     plugins.splice(0, 0, new PackageConfigSanityChecker_1.PackageConfigSanityChecker());
-    if (typeof dest !== 'string' && dest.bundleAnalyzer) {
+    if (dest.bundleAnalyzer) {
         plugins.splice(0, 0, new (require("webpack-bundle-analyzer").BundleAnalyzerPlugin)({ analyzerMode: 'static' }));
     }
     handleDisablingTSCheckerIfNecessary(srcRoot, scriptExtension, plugins);
@@ -279,19 +360,19 @@ function buildCommonPluginConfig(srcRoot, scriptExtension, webpackConfig, dest,
     if (variablesFilePath) {
         plugins.push(new VariablesJSMonitorPlugin_1.VariablesJSMonitorPlugin(variablesFilePath));
     }
-    const pluginIndex = plugins.findIndex(plugin => plugin instanceof dependency_extraction_webpack_plugin_1.default);
-    if (pluginIndex === -1) {
+    const dependencyExtractionPluginIndex = plugins.findIndex(plugin => plugin instanceof dependency_extraction_webpack_plugin_1.default);
+    if (dependencyExtractionPluginIndex === -1) {
         console.error("Cannot apply externals when they have been disabled via CLI flag. This will greatly increase bundle size and will likely cause the build to fail");
     }
     else {
-        const localAssumeGlobalizedPlauditLibraries = (typeof dest !== 'string' ? dest.assumeGlobalizedPlauditLibraries : undefined) ?? assumeGlobalizedPlauditLibraries;
+        const localAssumeGlobalizedPlauditLibraries = dest.assumeGlobalizedPlauditLibraries ?? assumeGlobalizedPlauditLibraries;
         const wantsGroupedDepData = combineAssetMetadata
             && ((!processingModules && sourceType === "blocks" /* SourceType.blocks */)
                 || (extensionsVersion > 1 && sourceType === "extensions" /* SourceType.extensions */)
                 || (plainEntrypointsVersion > 1 && sourceType === "plain" /* SourceType.plain */));
-        const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(externals, localAssumeGlobalizedPlauditLibraries, wantsGroupedDepData, typeof dest !== 'string' ? dest.externalize : undefined);
-        plugins[pluginIndex] = builtDependencyExtractionWebpackPlugin.instance;
-        plugins.push(new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(typeof dest !== 'string' && dest.additionalDependencies ? dest.additionalDependencies : [], processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep));
+        const builtDependencyExtractionWebpackPlugin = (0, dependency_extraction_webpack_plugin_config_builder_1.makeDependencyExtractionPlugin)(externals, localAssumeGlobalizedPlauditLibraries, wantsGroupedDepData, dest.externalize);
+        plugins[dependencyExtractionPluginIndex] = builtDependencyExtractionWebpackPlugin.instance;
+        plugins.push(new AdditionalDependencyInjectorPlugin_1.AdditionalDependencyInjectorPlugin(dest.additionalDependencies ? dest.additionalDependencies : [], processingModules, builtDependencyExtractionWebpackPlugin.addExternalizedDep));
     }
     if (process.argv.includes('--browser-sync') || process.env['BROWSER_SYNC'] === 'true') {
         plugins.push(new BrowserSyncPlugin_1.BrowserSyncPlugin());
@@ -303,11 +384,11 @@ function commonConfigProcessingPrep(config, webpackConfig) {
     let entrypointFields;
     const processingModules = webpackConfig.output?.module;
     if (processingModules) {
-        scriptExtension = common_config_helpers_1.scriptWithModuleExtension;
+        scriptExtension = shared_1.scriptWithModuleExtension;
         entrypointFields = ["viewScriptModule", "scriptModule"];
     }
     else {
-        scriptExtension = common_config_helpers_1.scriptWithoutModuleExtension;
+        scriptExtension = shared_1.scriptWithoutModuleExtension;
         entrypointFields = ["editorStyle", "viewStyle", "style", "editorScript", "viewScript", "script"];
     }
     let currentVariables = config.currentVariables;
@@ -333,6 +414,7 @@ function commonConfigProcessingPrep(config, webpackConfig) {
         updateCurrentVariables: (value) => currentVariables = value
     };
 }
+//TODO: Implement path deduplication w/ the same code we use for block.json (only for plain v2 w/ specified handles
 //TODO: Try using context to avoid needing to cobble dest paths together?
 function processIndividualWebpackConfig(config, webpackConfig, sources) {
     const commonConfig = commonConfigProcessingPrep(config, webpackConfig);
@@ -340,7 +422,7 @@ function processIndividualWebpackConfig(config, webpackConfig, sources) {
     return sources.map(([src, dest]) => {
         const srcRoots = (dest.withLegacyBlocksIn
             ? [...src.split(','), ...resolveLegacyBlockScriptsInFolder(node_path_1.default.join(config.srcDir, dest.withLegacyBlocksIn))]
-            : src.split(',')).filter(s => s.endsWith(".json") || !s.substring(s.lastIndexOf('/')).includes('.') || processingModules === common_config_helpers_1.scriptWithModuleExtension.test(s));
+            : src.split(',')).filter(s => s.endsWith(".json") || !s.substring(s.lastIndexOf('/')).includes('.') || processingModules === shared_1.scriptWithModuleExtension.test(s));
         const srcRoot = srcRoots.length < 2 ? (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(process.cwd(), src) : srcRoots.map(s => (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(process.cwd(), s));
         const srcIsDirectory = !Array.isArray(srcRoot) && node_fs_1.default.lstatSync(srcRoot, { throwIfNoEntry: false })?.isDirectory();
         if (srcIsDirectory === undefined) {
@@ -387,7 +469,7 @@ function makeExtensionsWebpackConfig(config, commonConfig, webpackConfig, dest,
         const rawEntrypoints = [];
         for await (const dirent of await promises_1.default.opendir(srcRoot)) {
             if (dirent.isFile() && !dirent.name.startsWith("~")) {
-                if (commonConfig.scriptExtension.test(dirent.name) || common_config_helpers_1.styleExtension.test(dirent.name)) {
+                if (commonConfig.scriptExtension.test(dirent.name) || shared_1.styleExtension.test(dirent.name)) {
                     const file = (0, common_config_helpers_1.joinPossiblyAbsolutePaths)(srcRoot, dirent.name);
                     rawEntrypoints.push([node_path_1.default.join(dest.destination, node_path_1.default.basename(file, node_path_1.default.extname(file))), file]);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "2.55.0",
+  "version": "2.56.0",
   "license": "UNLICENSED",
   "files": [
     "/build"