@rushstack/webpack5-localization-plugin 0.16.27 → 0.16.28

package/CHANGELOG.json

@@ -1,6 +1,26 @@
 {
   "name": "@rushstack/webpack5-localization-plugin",
   "entries": [
+    {
+      "version": "0.16.28",
+      "tag": "@rushstack/webpack5-localization-plugin_v0.16.28",
+      "date": "Mon, 14 Sep 2026 22:42:32 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Use ECMAScript private syntax for internal class members."
+          }
+        ],
+        "dependency": [
+          {
+            "comment": "Updating dependency \"@rushstack/localization-utilities\" to `0.16.5`"
+          },
+          {
+            "comment": "Updating dependency \"@rushstack/heft\" to `1.3.0`"
+          }
+        ]
+      }
+    },
     {
       "version": "0.16.27",
       "tag": "@rushstack/webpack5-localization-plugin_v0.16.27",

package/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Change Log - @rushstack/webpack5-localization-plugin
 
-This log was last generated on Sat, 05 Sep 2026 00:15:08 GMT and should not be manually modified.
+This log was last generated on Mon, 14 Sep 2026 22:42:32 GMT and should not be manually modified.
+
+## 0.16.28
+Mon, 14 Sep 2026 22:42:32 GMT
+
+_Version update only_
 
 ## 0.16.27
 Sat, 05 Sep 2026 00:15:08 GMT

package/dist/webpack5-localization-plugin.d.ts

@@ -280,30 +280,11 @@ export declare interface IValuePlaceholderBase {
  * @public
  */
 export declare class LocalizationPlugin implements WebpackPluginInstance {
-    private readonly _locFiles;
+    #private;
     /**
      * @internal
      */
     readonly _options: ILocalizationPluginOptions;
-    private readonly _resolvedTranslatedStringsFromOptions;
-    private readonly _stringPlaceholderBySuffix;
-    private readonly _customDataPlaceholderBySuffix;
-    private readonly _customDataPlaceholderByUniqueId;
-    private _passthroughLocaleName;
-    private _defaultLocale;
-    private _noStringsLocaleName;
-    private _fillMissingTranslationStrings;
-    /**
-     * @remarks
-     * Include the `chunk` parameter so that the functions arity is the same as the
-     * `ValueForLocaleFn` type.
-     */
-    private _formatLocaleForFilename;
-    private readonly _pseudolocalizers;
-    /**
-     * The set of locales that have translations provided.
-     */
-    private _translatedLocales;
     constructor(options: ILocalizationPluginOptions);
     /**
      * Apply this plugin to the specified webpack compiler.
@@ -331,15 +312,13 @@ export declare class LocalizationPlugin implements WebpackPluginInstance {
      * @internal
      */
     _getCustomDataForSerialNumber(suffix: string): _ICustomDataPlaceholder | undefined;
-    private _addLocFileAndGetPlaceholders;
-    private _initializeAndValidateOptions;
 }
 
 /**
  * @public
  */
 export declare class TrueHashPlugin implements WebpackPluginInstance {
-    private readonly _options;
+    #private;
     constructor(options?: ITrueHashPluginOptions);
     apply(compiler: Compiler): void;
 }

package/lib-commonjs/LocalizationPlugin.js

@@ -64,30 +64,30 @@ function getPluginInstance(compiler) {
  * @public
  */
 class LocalizationPlugin {
-    _locFiles = new Map();
+    #locFiles = new Map();
     /**
      * @internal
      */
     _options;
-    _resolvedTranslatedStringsFromOptions = new Map();
-    _stringPlaceholderBySuffix = new Map();
-    _customDataPlaceholderBySuffix = new Map();
-    _customDataPlaceholderByUniqueId = new Map();
-    _passthroughLocaleName;
-    _defaultLocale;
-    _noStringsLocaleName;
-    _fillMissingTranslationStrings;
+    #resolvedTranslatedStringsFromOptions = new Map();
+    #stringPlaceholderBySuffix = new Map();
+    #customDataPlaceholderBySuffix = new Map();
+    #customDataPlaceholderByUniqueId = new Map();
+    #passthroughLocaleName;
+    #defaultLocale;
+    #noStringsLocaleName;
+    #fillMissingTranslationStrings;
     /**
      * @remarks
      * Include the `chunk` parameter so that the functions arity is the same as the
      * `ValueForLocaleFn` type.
      */
-    _formatLocaleForFilename;
-    _pseudolocalizers = new Map();
+    #formatLocaleForFilename;
+    #pseudolocalizers = new Map();
     /**
      * The set of locales that have translations provided.
      */
-    _translatedLocales = new Set();
+    #translatedLocales = new Set();
     constructor(options) {
         this._options = options;
     }
@@ -98,7 +98,7 @@ class LocalizationPlugin {
         pluginForCompiler.set(compiler, this);
         // https://github.com/webpack/webpack-dev-server/pull/1929/files#diff-15fb51940da53816af13330d8ce69b4eR66
         const isWebpackDevServer = process.env.WEBPACK_DEV_SERVER === 'true';
-        const { errors, warnings } = this._initializeAndValidateOptions(compiler, isWebpackDevServer);
+        const { errors, warnings } = this.#initializeAndValidateOptions(compiler, isWebpackDevServer);
         if (errors.length > 0 || warnings.length > 0) {
             compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
                 compilation.errors.push(...errors);
@@ -180,7 +180,7 @@ class LocalizationPlugin {
                                 chunksWithUrlGenerators.add(activeChunkWithAsyncUrlGenerator);
                             }
                             if (chunkIdsWithStrings.size === 0) {
-                                return this._formatLocaleForFilename(this._noStringsLocaleName, undefined);
+                                return this.#formatLocaleForFilename(this.#noStringsLocaleName, undefined);
                             }
                             else if (chunkIdsWithoutStrings.size === 0) {
                                 return `" + ${localeExpression} + "`;
@@ -203,7 +203,7 @@ class LocalizationPlugin {
                                 for (const id of smallerSet) {
                                     chunkMapping[id] = 1;
                                 }
-                                const noLocaleExpression = JSON.stringify(this._formatLocaleForFilename(this._noStringsLocaleName, undefined));
+                                const noLocaleExpression = JSON.stringify(this.#formatLocaleForFilename(this.#noStringsLocaleName, undefined));
                                 return `" + (${JSON.stringify(chunkMapping)}[chunkId]?${isLocalizedSmaller ? localeExpression : noLocaleExpression}:${isLocalizedSmaller ? noLocaleExpression : localeExpression}) + "`;
                             }
                         });
@@ -213,9 +213,9 @@ class LocalizationPlugin {
                         if (!locale) {
                             const isLocalized = _chunkHasLocalizedModules(chunkGraph, options.chunk, runtimeLocaleExpression);
                             // Ensure that the initial name maps to a file that should exist in the final output
-                            locale = isLocalized ? this._defaultLocale : this._noStringsLocaleName;
+                            locale = isLocalized ? this.#defaultLocale : this.#noStringsLocaleName;
                         }
-                        return assetPath.replace(Constants.LOCALE_FILENAME_TOKEN_REGEX, this._formatLocaleForFilename(locale, undefined));
+                        return assetPath.replace(Constants.LOCALE_FILENAME_TOKEN_REGEX, this.#formatLocaleForFilename(locale, undefined));
                     }
                 }
                 else {
@@ -229,7 +229,7 @@ class LocalizationPlugin {
                 // Generating derived assets, but explicitly want to create them *after* asset optimization
                 stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING - 1
             }, async () => {
-                const locales = this._translatedLocales;
+                const locales = this.#translatedLocales;
                 const { chunkGraph, chunks } = compilation;
                 const { localizationStats: statsOptions } = this._options;
                 const filesByChunkName = statsOptions
@@ -262,10 +262,10 @@ class LocalizationPlugin {
                             compilation,
                             cache,
                             locales,
-                            defaultLocale: this._defaultLocale,
-                            passthroughLocaleName: this._passthroughLocaleName,
-                            fillMissingTranslationStrings: this._fillMissingTranslationStrings,
-                            formatLocaleForFilenameFn: this._formatLocaleForFilename,
+                            defaultLocale: this.#defaultLocale,
+                            passthroughLocaleName: this.#passthroughLocaleName,
+                            fillMissingTranslationStrings: this.#fillMissingTranslationStrings,
+                            formatLocaleForFilenameFn: this.#formatLocaleForFilename,
                             // Chunk-specific values
                             chunk,
                             asset,
@@ -283,8 +283,8 @@ class LocalizationPlugin {
                             compilation,
                             cache,
                             hasUrlGenerator: chunksWithUrlGenerators.has(chunk),
-                            noStringsLocaleName: this._noStringsLocaleName,
-                            formatLocaleForFilenameFn: this._formatLocaleForFilename,
+                            noStringsLocaleName: this.#noStringsLocaleName,
+                            formatLocaleForFilenameFn: this.#formatLocaleForFilename,
                             // Chunk-specific values
                             chunk,
                             asset,
@@ -346,9 +346,9 @@ class LocalizationPlugin {
      */
     async addDefaultLocFileAsync(context, localizedFileKey, localizedResourceData) {
         const locFileData = convertLocalizationFileToLocData(localizedResourceData);
-        const fileInfo = this._addLocFileAndGetPlaceholders(this._defaultLocale, localizedFileKey, locFileData);
+        const fileInfo = this.#addLocFileAndGetPlaceholders(this.#defaultLocale, localizedFileKey, locFileData);
         const missingLocales = [];
-        for (const [translatedLocaleName, translatedStrings] of this._resolvedTranslatedStringsFromOptions) {
+        for (const [translatedLocaleName, translatedStrings] of this.#resolvedTranslatedStringsFromOptions) {
             const translatedLocFileFromOptions = translatedStrings.get(localizedFileKey);
             if (!translatedLocFileFromOptions) {
                 missingLocales.push(translatedLocaleName);
@@ -379,7 +379,7 @@ class LocalizationPlugin {
                 }
             }
         }
-        for (const [pseudolocaleName, pseudolocalizer] of this._pseudolocalizers) {
+        for (const [pseudolocaleName, pseudolocalizer] of this.#pseudolocalizers) {
             const pseudolocFileData = new Map();
             for (const [stringName, stringValue] of locFileData) {
                 pseudolocFileData.set(stringName, pseudolocalizer(stringValue));
@@ -393,7 +393,7 @@ class LocalizationPlugin {
      * @public
      */
     getPlaceholder(localizedFileKey, stringName) {
-        const file = this._locFiles.get(localizedFileKey);
+        const file = this.#locFiles.get(localizedFileKey);
         if (!file) {
             return undefined;
         }
@@ -403,7 +403,7 @@ class LocalizationPlugin {
      * @beta
      */
     getCustomDataPlaceholderForValueFunction(valueForLocaleFn, placeholderUniqueId) {
-        let placeholder = this._customDataPlaceholderByUniqueId.get(placeholderUniqueId);
+        let placeholder = this.#customDataPlaceholderByUniqueId.get(placeholderUniqueId);
         if (!placeholder) {
             // Get a hash of the unique ID to make sure its value doesn't interfere with our placeholder tokens
             const suffix = Buffer.from(placeholderUniqueId, 'utf-8').toString('hex');
@@ -412,8 +412,8 @@ class LocalizationPlugin {
                 suffix,
                 valueForLocaleFn
             };
-            this._customDataPlaceholderBySuffix.set(suffix, placeholder);
-            this._customDataPlaceholderByUniqueId.set(placeholderUniqueId, placeholder);
+            this.#customDataPlaceholderBySuffix.set(suffix, placeholder);
+            this.#customDataPlaceholderByUniqueId.set(placeholderUniqueId, placeholder);
         }
         else if (placeholder.valueForLocaleFn !== valueForLocaleFn) {
             throw new Error(`${this.getCustomDataPlaceholderForValueFunction.name} has already been called with "${placeholderUniqueId}" ` +
@@ -425,23 +425,23 @@ class LocalizationPlugin {
      * @internal
      */
     _getStringDataForSerialNumber(suffix) {
-        return this._stringPlaceholderBySuffix.get(suffix);
+        return this.#stringPlaceholderBySuffix.get(suffix);
     }
     /**
      * @internal
      */
     _getCustomDataForSerialNumber(suffix) {
-        return this._customDataPlaceholderBySuffix.get(suffix);
+        return this.#customDataPlaceholderBySuffix.get(suffix);
     }
-    _addLocFileAndGetPlaceholders(localeName, localizedFileKey, localizedFileData) {
-        let fileInfo = this._locFiles.get(localizedFileKey);
+    #addLocFileAndGetPlaceholders(localeName, localizedFileKey, localizedFileData) {
+        let fileInfo = this.#locFiles.get(localizedFileKey);
         if (!fileInfo) {
             fileInfo = {
                 placeholders: new Map(),
                 translations: new Map(),
                 renderedPlaceholders: {}
             };
-            this._locFiles.set(localizedFileKey, fileInfo);
+            this.#locFiles.set(localizedFileKey, fileInfo);
         }
         const { placeholders, translations } = fileInfo;
         const locFilePrefix = Buffer.from(localizedFileKey, 'utf-8').toString('hex') + '$';
@@ -458,7 +458,7 @@ class LocalizationPlugin {
                     stringName
                 };
                 placeholders.set(stringName, placeholder);
-                this._stringPlaceholderBySuffix.set(suffix, placeholder);
+                this.#stringPlaceholderBySuffix.set(suffix, placeholder);
             }
             resultObject[stringName] = placeholder.value;
         }
@@ -466,7 +466,7 @@ class LocalizationPlugin {
         fileInfo.renderedPlaceholders = resultObject;
         return fileInfo;
     }
-    _initializeAndValidateOptions(compiler, isWebpackDevServer) {
+    #initializeAndValidateOptions(compiler, isWebpackDevServer) {
         const errors = [];
         const warnings = [];
         const { WebpackError } = compiler.webpack;
@@ -499,18 +499,18 @@ class LocalizationPlugin {
             if (passthroughLocale) {
                 const { usePassthroughLocale, passthroughLocaleName = 'passthrough' } = passthroughLocale;
                 if (usePassthroughLocale) {
-                    this._passthroughLocaleName = passthroughLocaleName;
-                    this._translatedLocales.add(passthroughLocaleName);
+                    this.#passthroughLocaleName = passthroughLocaleName;
+                    this.#translatedLocales.add(passthroughLocaleName);
                 }
             }
             // END options.localizedData.passthroughLocale
             // START options.localizedData.translatedStrings
             const resolveRelativeToContext = (configuration.context?.startsWith('/') ? path.posix.resolve : path.resolve).bind(0, configuration.context);
             const { translatedStrings } = localizedData;
-            this._resolvedTranslatedStringsFromOptions.clear();
+            this.#resolvedTranslatedStringsFromOptions.clear();
             if (translatedStrings) {
                 for (const [localeName, locale] of Object.entries(translatedStrings)) {
-                    if (this._translatedLocales.has(localeName)) {
+                    if (this.#translatedLocales.has(localeName)) {
                         errors.push(new WebpackError(`The locale "${localeName}" appears multiple times. ` +
                             'There may be multiple instances with different casing.'));
                         return { errors, warnings };
@@ -518,9 +518,9 @@ class LocalizationPlugin {
                     if (!ensureValidLocaleName(localeName)) {
                         return { errors, warnings };
                     }
-                    this._translatedLocales.add(localeName);
+                    this.#translatedLocales.add(localeName);
                     const resolvedFromOptionsForLocale = new Map();
-                    this._resolvedTranslatedStringsFromOptions.set(localeName, resolvedFromOptionsForLocale);
+                    this.#resolvedTranslatedStringsFromOptions.set(localeName, resolvedFromOptionsForLocale);
                     for (const [locFilePath, locFileDataFromOptions] of Object.entries(locale)) {
                         const normalizedLocFilePath = resolveRelativeToContext(locFilePath);
                         if (resolvedFromOptionsForLocale.has(normalizedLocFilePath)) {
@@ -541,16 +541,16 @@ class LocalizationPlugin {
             if (defaultLocale) {
                 const { localeName, fillMissingTranslationStrings } = defaultLocale;
                 if (localeName) {
-                    if (this._translatedLocales.has(localeName)) {
+                    if (this.#translatedLocales.has(localeName)) {
                         errors.push(new WebpackError('The default locale is also specified in the translated strings.'));
                         return { errors, warnings };
                     }
                     else if (!ensureValidLocaleName(localeName)) {
                         return { errors, warnings };
                     }
-                    this._translatedLocales.add(localeName);
-                    this._defaultLocale = localeName;
-                    this._fillMissingTranslationStrings = !!fillMissingTranslationStrings;
+                    this.#translatedLocales.add(localeName);
+                    this.#defaultLocale = localeName;
+                    this.#fillMissingTranslationStrings = !!fillMissingTranslationStrings;
                 }
                 else {
                     errors.push(new WebpackError('Missing default locale name'));
@@ -566,16 +566,16 @@ class LocalizationPlugin {
             const { pseudolocales } = localizedData;
             if (pseudolocales) {
                 for (const [pseudolocaleName, pseudoLocaleOpts] of Object.entries(pseudolocales)) {
-                    if (this._defaultLocale === pseudolocaleName) {
+                    if (this.#defaultLocale === pseudolocaleName) {
                         errors.push(new WebpackError(`A pseudolocale (${pseudolocaleName}) name is also the default locale name.`));
                         return { errors, warnings };
                     }
-                    if (this._translatedLocales.has(pseudolocaleName)) {
+                    if (this.#translatedLocales.has(pseudolocaleName)) {
                         errors.push(new WebpackError(`A pseudolocale (${pseudolocaleName}) name is also specified in the translated strings.`));
                         return { errors, warnings };
                     }
-                    this._pseudolocalizers.set(pseudolocaleName, (0, localization_utilities_1.getPseudolocalizer)(pseudoLocaleOpts));
-                    this._translatedLocales.add(pseudolocaleName);
+                    this.#pseudolocalizers.set(pseudolocaleName, (0, localization_utilities_1.getPseudolocalizer)(pseudoLocaleOpts));
+                    this.#translatedLocales.add(pseudolocaleName);
                 }
             }
             // END options.localizedData.pseudoLocales
@@ -589,15 +589,15 @@ class LocalizationPlugin {
         if (noStringsLocaleName === undefined ||
             noStringsLocaleName === null ||
             !ensureValidLocaleName(noStringsLocaleName)) {
-            this._noStringsLocaleName = 'none';
+            this.#noStringsLocaleName = 'none';
         }
         else {
-            this._noStringsLocaleName = noStringsLocaleName;
+            this.#noStringsLocaleName = noStringsLocaleName;
         }
         // END options.noStringsLocaleName
         // START options.formatLocaleForFilename
         const { formatLocaleForFilename = (localeName) => localeName } = this._options;
-        this._formatLocaleForFilename = formatLocaleForFilename;
+        this.#formatLocaleForFilename = formatLocaleForFilename;
         // END options.formatLocaleForFilename
         return { errors, warnings };
     }