apply new changes for language setoption and add new test

Author: Parvinmh

src/i18n/language.ts

@@ -15,6 +15,7 @@ const languages = {
 } as const;
 
 export type LanguageCode = keyof typeof languages;
+export const DefaultLanguage: LanguageCode = "en_US";
 
 /**
  * Get all available language codes
@@ -33,14 +34,14 @@ export class Translator {
       const rawLang = (
         navigator.language ||
         (navigator as any).userLanguage ||
-        "en-US"
+        DefaultLanguage
       ).replace("-", "_");
 
       const normalizedLang = (Object.keys(languages) as LanguageCode[]).find(
         (key) => key.toLowerCase() === rawLang.toLowerCase()
       );
 
-      this._languageCode = normalizedLang ?? "en_US";
+      this._languageCode = normalizedLang ?? DefaultLanguage;
     }
   }
 

src/option.test.ts

@@ -1,4 +1,5 @@
 import { setOption, setOptions } from "./option";
+import { Translator } from "./i18n/language";
 
 Object.defineProperty(global, "navigator", {
   value: { language: "en-US" },
@@ -13,7 +14,7 @@ describe("option", () => {
       // Act → capture return value
       const result = setOption(mockOption, "key1", "newValue1");
 
-      // Assert
+      //Assert
       expect(result.key1).toBe("newValue1");
       expect(mockOption.key1).toBe("value1");
     });
@@ -40,19 +41,19 @@ describe("option", () => {
   describe("setOptions with language", () => {
     it("should set language when provided", () => {
       const mockOption: any = {};
-
+      // Act
       const result = setOptions(mockOption, { language: "fr_FR" });
-
+      // Assert
       expect(result.language).toEqual("fr_FR");
     });
 
     it("should not override language when other options change", () => {
       const mockOption: any = {
         language: "en_US",
       };
-
+      // Act
       const result = setOptions(mockOption, { htmlRender: true });
-
+      // Assert
       expect(result.language).toEqual("en_US");
       expect(result.htmlRender).toBe(true);
     });
@@ -63,16 +64,72 @@ describe("option", () => {
         htmlRender: true,
         customProp: "test",
       };
-
-      // Change language via setOption
+      // Act
       const updatedOption = setOption(mockOption, "language", "fr_FR");
-
-      // Assert language updated
+      // Assert
       expect(updatedOption.language).toEqual("fr_FR");
-
-      // Other options should remain
       expect(updatedOption.htmlRender).toBe(true);
       expect(updatedOption.customProp).toBe("test");
     });
   });
+
+  describe("Label handling and emoji overrides", () => {
+    it("should override label with emoji when language is already set", () => {
+      const options: any = {
+        language: "de_DE",
+        nextLabel: "Weiter",
+        prevLabel: "Zurück",
+        doneLabel: "Fertig",
+      };
+
+      const updated = setOptions(options, { nextLabel: "➡️" });
+
+      expect(updated.nextLabel).toBe("➡️"); // emoji kept
+      expect(updated.prevLabel).toBe("Zurück"); // other labels stay German
+      expect(updated.doneLabel).toBe("Fertig");
+    });
+
+    it("overWritten emoji label when changing language", () => {
+      const options: any = {
+        language: "de_DE",
+        nextLabel: "➡️",
+        prevLabel: "Zurück",
+        doneLabel: "Fertig",
+      };
+
+      const updated = setOptions(options, { language: "fr_FR" });
+
+      expect(updated.nextLabel).toBe("Suivant"); // emoji overWritten by French
+      const t = new Translator("fr_FR");
+      expect(updated.prevLabel).toBe(t.translate("buttons.prev")); // now French
+      expect(updated.doneLabel).toBe(t.translate("buttons.done"));
+    });
+
+    it("should retranslate all labels if none are custom", () => {
+      const options: any = { language: "en_US" };
+      const updated = setOptions(options, { language: "de_DE" });
+
+      const t = new Translator("de_DE");
+      expect(updated.nextLabel).toBe(t.translate("buttons.next"));
+      expect(updated.prevLabel).toBe(t.translate("buttons.prev"));
+      expect(updated.doneLabel).toBe(t.translate("buttons.done"));
+    });
+
+    it("should keep emoji doneLabel when language is not set", () => {
+      const defaultOptions: any = {
+        nextLabel: "Next",
+        prevLabel: "Back",
+        doneLabel: "Done",
+      };
+
+      const withEmoji = setOptions(defaultOptions, { doneLabel: "✅" });
+
+      const afterStart = setOptions(withEmoji, { isActive: true });
+
+      expect(afterStart.doneLabel).toBe("✅");
+
+      expect(afterStart.nextLabel).toBe("Next");
+      expect(afterStart.prevLabel).toBe("Back");
+    });
+  });
 });

src/option.ts

@@ -1,49 +1,38 @@
 import { getDefaultTourOptions, TourOptions } from "./packages/tour/option";
 import { getDefaultHintOptions, HintOptions } from "./packages/hint/option";
-import { Translator } from "./i18n/language";
+import { Translator, DefaultLanguage } from "./i18n/language";
 
 function isHintOptions(options: any): options is HintOptions {
   return "hints" in options;
 }
 
-/**
- * Ensures a valid Translator instance exists for a tour or hint.
- * Translator is **not** part of the public options.
- */
-function ensureTranslator(options: Partial<TourOptions | HintOptions>) {
-  const language = options.language ?? "en_US";
-
-  const translator = new Translator();
-  translator.setLanguage(language);
-  return translator;
-}
-
 export function applyLanguageDefaults<T extends TourOptions | HintOptions>(
   options: T
 ): T {
-  const translator = ensureTranslator(options);
+  const language = options.language ?? DefaultLanguage;
+  const translator = new Translator();
+  translator.setLanguage(language);
 
-  const defaults = isHintOptions(options)
-    ? getDefaultHintOptions(translator)
-    : getDefaultTourOptions(translator);
+  if (isHintOptions(options)) {
+    const translatedOptions = getDefaultHintOptions(translator);
 
-  const {
-    nextLabel,
-    prevLabel,
-    skipLabel,
-    doneLabel,
-    stepNumbersOfLabel,
-    dontShowAgainLabel,
-    hintButtonLabel,
-    language: _,
-    ...userOptions
-  } = options as any;
+    return {
+      ...options,
+      hintButtonLabel: translatedOptions.hintButtonLabel,
+    };
+  } else {
+    const translatedOptions = getDefaultTourOptions(translator);
 
-  return {
-    ...defaults,
-    ...userOptions,
-    language: translator.getLanguage(),
-  } as T;
+    return {
+      ...options,
+      doneLabel: translatedOptions.doneLabel,
+      nextLabel: translatedOptions.nextLabel,
+      prevLabel: translatedOptions.prevLabel,
+      skipLabel: translatedOptions.skipLabel,
+      dontShowAgainLabel: translatedOptions.dontShowAgainLabel,
+      stepNumbersOfLabel: translatedOptions.stepNumbersOfLabel,
+    };
+  }
 }
 
 /**