@itwin/core-i18n 5.14.0-dev.7 → 5.14.0-dev.9

package/lib/cjs/test/webpack/bundled-tests.js

@@ -22480,23 +22480,9 @@ class ITwinLocalization {
             this.i18next.loadNamespaces(name, (err) => {
                 if (!err)
                     return resolve();
-                // Here we got a non-null err object.
-                // This method is called when the system has attempted to load the resources for the namespaces for each possible locale.
-                // For example 'fr-ca' might be the most specific locale, in which case 'fr' and 'en' are fallback locales.
-                // Using Backend from i18next-http-backend, err will be an array of strings of each namespace it tried to read and its locale.
-                // There might be errs for some other namespaces as well as this one. We resolve the promise unless there's an error for each possible locale.
-                let locales = this.getLanguageList().map((thisLocale) => `/${thisLocale}/`);
-                try {
-                    for (const thisError of err) {
-                        if (typeof thisError === "string")
-                            locales = locales.filter((thisLocale) => !thisError.includes(thisLocale));
-                    }
-                }
-                catch {
-                    locales = [];
-                }
-                // if we removed every locale from the array, it wasn't loaded.
-                if (locales.length === 0)
+                // i18next can return errors from other concurrent namespace loads in this callback.
+                const wasLoaded = this.getLanguageList().some((language) => this.i18next.hasResourceBundle(language, name));
+                if (!wasLoaded)
                     core_bentley_1.Logger.logError("i18n", `No resources for namespace ${name} could be loaded`);
                 resolve();
             });
@@ -23636,6 +23622,7 @@ let exports = __webpack_exports__;
 *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const chai_1 = __webpack_require__(/*! chai */ "../../common/temp/node_modules/.pnpm/chai@4.5.0/node_modules/chai/index.js");
+const core_bentley_1 = __webpack_require__(/*! @itwin/core-bentley */ "../bentley/lib/esm/core-bentley.js");
 const ITwinLocalization_1 = __webpack_require__(/*! ../ITwinLocalization */ "./lib/cjs/ITwinLocalization.js");
 describe("ITwinLocalization", () => {
     let localization;
@@ -24502,6 +24489,65 @@ describe("ITwinLocalization", () => {
             chai_1.assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("Test"));
             chai_1.assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
         });
+        it("attributes errors from concurrent namespace loads to the namespace that failed", async () => {
+            const pendingLoads = new Map();
+            const backend = {
+                type: "backend",
+                init: () => { },
+                read: (_language, namespace, callback) => pendingLoads.set(namespace, callback),
+            };
+            itwinLocalization = new ITwinLocalization_1.ITwinLocalization({
+                backendPlugin: backend,
+                initOptions: { lng: "en", fallbackLng: false },
+            });
+            await itwinLocalization.initialize([]);
+            const loggedErrors = [];
+            // eslint-disable-next-line @typescript-eslint/unbound-method -- Preserve the exact method reference so the test can restore it.
+            const originalLogError = core_bentley_1.Logger.logError;
+            core_bentley_1.Logger.logError = (_category, message) => loggedErrors.push(String(message));
+            try {
+                const loadedPromise = itwinLocalization.registerNamespace("Loaded");
+                const missingPromise = itwinLocalization.registerNamespace("Missing");
+                chai_1.assert.sameMembers([...pendingLoads.keys()], ["Loaded", "Missing"]);
+                pendingLoads.get("Missing")?.(new Error("Missing namespace"), false);
+                pendingLoads.get("Loaded")?.(null, { key: "value" });
+                await Promise.all([missingPromise, loadedPromise]);
+                chai_1.assert.deepEqual(loggedErrors, ["No resources for namespace Missing could be loaded"]);
+                chai_1.assert.isTrue(itwinLocalization.i18next.hasResourceBundle("en", "Loaded"));
+            }
+            finally {
+                core_bentley_1.Logger.logError = originalLogError;
+            }
+        });
+        it("does not log an error when a namespace loads from a fallback language", async () => {
+            const pendingLoads = new Map();
+            const backend = {
+                type: "backend",
+                init: () => { },
+                read: (language, namespace, callback) => pendingLoads.set(`${language}/${namespace}`, callback),
+            };
+            itwinLocalization = new ITwinLocalization_1.ITwinLocalization({
+                backendPlugin: backend,
+                initOptions: { lng: "fr", fallbackLng: "en" },
+            });
+            await itwinLocalization.initialize([]);
+            const loggedErrors = [];
+            // eslint-disable-next-line @typescript-eslint/unbound-method -- Preserve the exact method reference so the test can restore it.
+            const originalLogError = core_bentley_1.Logger.logError;
+            core_bentley_1.Logger.logError = (_category, message) => loggedErrors.push(String(message));
+            try {
+                const loadPromise = itwinLocalization.registerNamespace("Fallback");
+                chai_1.assert.sameMembers([...pendingLoads.keys()], ["fr/Fallback", "en/Fallback"]);
+                pendingLoads.get("fr/Fallback")?.(new Error("Missing French namespace"), false);
+                pendingLoads.get("en/Fallback")?.(null, { key: "value" });
+                await loadPromise;
+                chai_1.assert.isEmpty(loggedErrors);
+                chai_1.assert.isTrue(itwinLocalization.i18next.hasResourceBundle("en", "Fallback"));
+            }
+            finally {
+                core_bentley_1.Logger.logError = originalLogError;
+            }
+        });
     });
     // unregisterNamespace() isn't used and basically does nothing
     // describe("#unregisterNamespace", () => {