@itwin/core-i18n 3.5.0-dev.8 → 3.6.0-dev.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (18) hide show
  1. package/CHANGELOG.md +60 -1
  2. package/lib/cjs/ITwinLocalization.d.ts +2 -1
  3. package/lib/cjs/ITwinLocalization.d.ts.map +1 -1
  4. package/lib/cjs/ITwinLocalization.js +6 -1
  5. package/lib/cjs/ITwinLocalization.js.map +1 -1
  6. package/lib/cjs/test/ITwinLocalization.test.js +747 -3
  7. package/lib/cjs/test/ITwinLocalization.test.js.map +1 -1
  8. package/lib/cjs/test/webpack/bundled-tests.instrumented.js +27438 -0
  9. package/lib/cjs/test/webpack/bundled-tests.instrumented.js.map +1 -0
  10. package/lib/cjs/test/webpack/bundled-tests.js +1316 -437
  11. package/lib/cjs/test/webpack/bundled-tests.js.map +1 -1
  12. package/lib/esm/ITwinLocalization.d.ts +2 -1
  13. package/lib/esm/ITwinLocalization.d.ts.map +1 -1
  14. package/lib/esm/ITwinLocalization.js +6 -1
  15. package/lib/esm/ITwinLocalization.js.map +1 -1
  16. package/lib/esm/test/ITwinLocalization.test.js +747 -3
  17. package/lib/esm/test/ITwinLocalization.test.js.map +1 -1
  18. package/package.json +11 -9
package/lib/esm/test/ITwinLocalization.test.js CHANGED
@@ -6,9 +6,80 @@ import { assert } from "chai";
6
6
  import { ITwinLocalization } from "../ITwinLocalization";
7
7
  describe("ITwinLocalization", () => {
8
8
  let localization;
9
+ let germanLocalization;
10
+ describe("#constructor", () => {
11
+ let itwinLocalization;
12
+ it("set default namespace", async () => {
13
+ itwinLocalization = new ITwinLocalization({ initOptions: { defaultNS: "Default" } });
14
+ await itwinLocalization.initialize([]);
15
+ assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
16
+ assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
17
+ });
18
+ it("set default language as english", async () => {
19
+ itwinLocalization = new ITwinLocalization({ initOptions: { defaultNS: "Default", lng: "en" } });
20
+ await itwinLocalization.initialize([]);
21
+ assert.equal(itwinLocalization.i18next.options.lng, "en");
22
+ assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
23
+ });
24
+ it("set default language as NOT english", async () => {
25
+ itwinLocalization = new ITwinLocalization({ initOptions: { defaultNS: "Default", lng: "de" } });
26
+ await itwinLocalization.initialize([]);
27
+ assert.equal(itwinLocalization.i18next.options.lng, "de");
28
+ assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default german)");
29
+ });
30
+ it("set fallback language as NOT english", async () => {
31
+ itwinLocalization = new ITwinLocalization({ initOptions: { defaultNS: "Default", fallbackLng: "de" } });
32
+ await itwinLocalization.initialize([]);
33
+ assert.equal(itwinLocalization.i18next.options.fallbackLng, "de");
34
+ assert.equal(itwinLocalization.getLocalizedString("OnlyGerman"), "Hallo");
35
+ });
36
+ });
9
37
  describe("#initialize", () => {
10
- describe("with default namespace provided in constructor", () => {
11
- let itwinLocalization;
38
+ let itwinLocalization;
39
+ it("cannot fetch from unregistered namespaces", async () => {
40
+ localization = new ITwinLocalization();
41
+ await localization.initialize([]);
42
+ assert.equal(localization.getEnglishString("Default", "FirstTrivial"), "FirstTrivial");
43
+ assert.equal(localization.getLocalizedString("Test:FirstTrivial"), "FirstTrivial");
44
+ });
45
+ describe("with no default namespace predefined", () => {
46
+ before(() => {
47
+ itwinLocalization = new ITwinLocalization();
48
+ });
49
+ it("no default namespace set when initialized with empty array", async () => {
50
+ await itwinLocalization.initialize([]);
51
+ assert.equal(itwinLocalization.i18next.options.defaultNS, undefined);
52
+ });
53
+ it("initialize with single namespace", async () => {
54
+ var _a;
55
+ await itwinLocalization.initialize(["Test"]);
56
+ assert.equal(itwinLocalization.i18next.options.defaultNS, "Test");
57
+ assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Test"));
58
+ assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
59
+ });
60
+ it("initialize with two namespaces recognizes both namespaces", async () => {
61
+ var _a, _b;
62
+ await itwinLocalization.initialize(["Default", "Test"]);
63
+ assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Default"));
64
+ assert.isTrue((_b = itwinLocalization.i18next.options.ns) === null || _b === void 0 ? void 0 : _b.includes("Test"));
65
+ assert.equal(itwinLocalization.getLocalizedString("Default:FirstTrivial"), "First level string (default)");
66
+ assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
67
+ });
68
+ it("initialize with two namespaces sets first as default", async () => {
69
+ await itwinLocalization.initialize(["Default", "Test"]);
70
+ assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
71
+ assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
72
+ });
73
+ it("initialize with duplicate namespace values does not break anything", async () => {
74
+ var _a;
75
+ await itwinLocalization.initialize(["Default", "Default"]);
76
+ assert.equal(itwinLocalization.i18next.options.defaultNS, "Default");
77
+ assert.isTrue((_a = itwinLocalization.i18next.options.ns) === null || _a === void 0 ? void 0 : _a.includes("Default"));
78
+ assert.equal(itwinLocalization.getLocalizedString("FirstTrivial"), "First level string (default)");
79
+ assert.equal(itwinLocalization.getLocalizedString("Default:FirstTrivial"), "First level string (default)");
80
+ });
81
+ });
82
+ describe("with default namespace", () => {
12
83
  before(() => {
13
84
  itwinLocalization = new ITwinLocalization({ initOptions: { defaultNS: "Default" } });
14
85
  });
@@ -40,6 +111,93 @@ describe("ITwinLocalization", () => {
40
111
  });
41
112
  });
42
113
  });
114
+ describe("#getLocalizedKeys", () => {
115
+ before(async () => {
116
+ localization = new ITwinLocalization();
117
+ await localization.initialize(["Default", "Test"]);
118
+ germanLocalization = new ITwinLocalization({ initOptions: { lng: "de" } });
119
+ await germanLocalization.initialize(["Default", "Test"]);
120
+ });
121
+ it("no substitution", () => {
122
+ assert.equal(localization.getLocalizedKeys("MyString"), "MyString");
123
+ });
124
+ describe("Default Namespace", () => {
125
+ it("first level string", () => {
126
+ assert.equal(localization.getLocalizedKeys("hi %{FirstTrivial}"), "hi First level string (default)");
127
+ assert.equal(germanLocalization.getLocalizedKeys("hi %{FirstTrivial}"), "hi First level string (default german)");
128
+ });
129
+ it("second level string", () => {
130
+ assert.equal(localization.getLocalizedKeys("%{SecondTrivial.Test1}"), "Second level string 1 (default)");
131
+ assert.equal(localization.getLocalizedKeys("bye %{SecondTrivial.Test2}"), "bye Second level string 2 (default)");
132
+ assert.equal(germanLocalization.getLocalizedKeys("%{SecondTrivial.Test1}"), "Second level string 1 (default german)");
133
+ assert.equal(germanLocalization.getLocalizedKeys("bye %{SecondTrivial.Test2}"), "bye Second level string 2 (default german)");
134
+ });
135
+ it("first level string with keys", () => {
136
+ assert.equal(localization.getLocalizedKeys("%{FirstSubstitution1}"), "First level {{str}} (default)");
137
+ assert.equal(localization.getLocalizedKeys("bye %{FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (default)");
138
+ assert.equal(germanLocalization.getLocalizedKeys("%{FirstSubstitution1}"), "First level {{str}} (default german)");
139
+ assert.equal(germanLocalization.getLocalizedKeys("bye %{FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (default german)");
140
+ });
141
+ it("second level string with keys", () => {
142
+ assert.equal(localization.getLocalizedKeys("%{SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (default)");
143
+ assert.equal(localization.getLocalizedKeys("hi %{SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (default)");
144
+ assert.equal(germanLocalization.getLocalizedKeys("%{SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (default german)");
145
+ assert.equal(germanLocalization.getLocalizedKeys("hi %{SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (default german)");
146
+ });
147
+ it("first level missing key doesn't find a value", () => {
148
+ assert.equal(localization.getLocalizedKeys("no %{MissingKeyString}"), "no MissingKeyString");
149
+ assert.equal(localization.getLocalizedKeys("no %{MissingKeyString}"), "no MissingKeyString");
150
+ });
151
+ it("second level missing key doesn't find a value", () => {
152
+ assert.equal(localization.getLocalizedKeys("hi %{SecondTrivial.MissingString}"), "hi SecondTrivial.MissingString");
153
+ assert.equal(localization.getLocalizedKeys("%{MissingKeyObject.MissingString}"), "MissingKeyObject.MissingString");
154
+ });
155
+ });
156
+ describe("Given Namespace", () => {
157
+ it("first level string", () => {
158
+ assert.equal(localization.getLocalizedKeys("hi %{Default:FirstTrivial}"), "hi First level string (default)");
159
+ assert.equal(localization.getLocalizedKeys("hi %{Test:FirstTrivial}"), "hi First level string (test)");
160
+ });
161
+ it("second level string", () => {
162
+ assert.equal(localization.getLocalizedKeys("%{Default:SecondTrivial.Test1}"), "Second level string 1 (default)");
163
+ assert.equal(localization.getLocalizedKeys("bye %{Default:SecondTrivial.Test2}"), "bye Second level string 2 (default)");
164
+ assert.equal(localization.getLocalizedKeys("%{Test:SecondTrivial.Test1}"), "Second level string 1 (test)");
165
+ assert.equal(localization.getLocalizedKeys("bye %{Test:SecondTrivial.Test2}"), "bye Second level string 2 (test)");
166
+ });
167
+ it("first level string with keys", () => {
168
+ assert.equal(localization.getLocalizedKeys("%{Default:FirstSubstitution1}"), "First level {{str}} (default)");
169
+ assert.equal(localization.getLocalizedKeys("bye %{Default:FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (default)");
170
+ assert.equal(localization.getLocalizedKeys("%{Test:FirstSubstitution1}"), "First level {{str}} (test)");
171
+ assert.equal(localization.getLocalizedKeys("bye %{Test:FirstSubstitution2}"), "bye First level {{str1}} and {{str2}} (test)");
172
+ });
173
+ it("second level string with keys", () => {
174
+ assert.equal(localization.getLocalizedKeys("%{Default:SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (default)");
175
+ assert.equal(localization.getLocalizedKeys("hi %{Default:SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (default)");
176
+ assert.equal(localization.getLocalizedKeys("%{Test:SecondSubstitution.Test1}"), "Substitute {{varA}} and {{varB}} (test)");
177
+ assert.equal(localization.getLocalizedKeys("hi %{Test:SecondSubstitution.Test2}"), "hi Reverse substitute {{varB}} and {{varA}} (test)");
178
+ });
179
+ it("first level missing key doesn't find a value", () => {
180
+ assert.equal(localization.getLocalizedKeys("no %{Default:MissingKeyString}"), "no MissingKeyString");
181
+ assert.equal(localization.getLocalizedKeys("no %{Test:MissingKeyString}"), "no MissingKeyString");
182
+ });
183
+ it("second level missing key doesn't find a value", () => {
184
+ assert.equal(localization.getLocalizedKeys("hi %{Default:SecondTrivial.MissingString}"), "hi SecondTrivial.MissingString");
185
+ assert.equal(localization.getLocalizedKeys("%{Default:MissingKeyObject.MissingString}"), "MissingKeyObject.MissingString");
186
+ assert.equal(localization.getLocalizedKeys("hi %{Test:SecondTrivial.MissingString}"), "hi SecondTrivial.MissingString");
187
+ assert.equal(localization.getLocalizedKeys("%{Test:MissingKeyObject.MissingString}"), "MissingKeyObject.MissingString");
188
+ });
189
+ });
190
+ describe("Nonexisting Namespace", () => {
191
+ it("first level fails", () => {
192
+ assert.equal(localization.getLocalizedKeys("%{Nonexisting:FirstTrivial}"), "FirstTrivial");
193
+ assert.equal(localization.getLocalizedKeys("%{Nonexisting:MissingKeyString}"), "MissingKeyString");
194
+ });
195
+ it("second level fails", () => {
196
+ assert.equal(localization.getLocalizedKeys("%{Nonexisting:SecondTrivial.Test1}"), "SecondTrivial.Test1");
197
+ assert.equal(localization.getLocalizedKeys("%{Nonexisting:Missing.String}"), "Missing.String");
198
+ });
199
+ });
200
+ });
43
201
  // The goal is not to test i18next's interpolation,
44
202
  // but just to have some simple tests to make sure the
45
203
  // basics work through the ITwinLocalization class.
@@ -48,30 +206,106 @@ describe("ITwinLocalization", () => {
48
206
  before(async () => {
49
207
  localization = new ITwinLocalization();
50
208
  await localization.initialize(["Default", "Test"]);
209
+ germanLocalization = new ITwinLocalization({ initOptions: { lng: "de" } });
210
+ await germanLocalization.initialize(["Default", "Test"]);
51
211
  });
52
212
  describe("Default Namespace", () => {
53
213
  it("first level with no substitution", () => {
54
214
  assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default)");
55
215
  });
216
+ it("first level with no substitution with fallback keys", () => {
217
+ assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist"]), "First level string (default)");
218
+ assert.equal(localization.getLocalizedString(["NotExist", "FirstTrivial"]), "First level string (default)");
219
+ });
220
+ it("more than two fallback keys succeeds", () => {
221
+ assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist1", "NotExist2"]), "First level string (default)");
222
+ assert.equal(localization.getLocalizedString(["NotExist1", "FirstTrivial", "NotExist2"]), "First level string (default)");
223
+ assert.equal(localization.getLocalizedString(["NotExist1", "NotExist2", "FirstTrivial"]), "First level string (default)");
224
+ assert.equal(localization.getLocalizedString(["1", "2", "3", "4", "5", "FirstTrivial"]), "First level string (default)");
225
+ });
56
226
  it("second level with no substitution", () => {
57
227
  assert.equal(localization.getLocalizedString("SecondTrivial.Test1"), "Second level string 1 (default)");
58
228
  assert.equal(localization.getLocalizedString("SecondTrivial.Test2"), "Second level string 2 (default)");
59
229
  });
230
+ it("second level with no substitution with fallback keys", () => {
231
+ assert.equal(localization.getLocalizedString(["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default)");
232
+ assert.equal(localization.getLocalizedString(["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (default)");
233
+ });
60
234
  it("first level with substitution", () => {
61
235
  assert.equal(localization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
62
236
  assert.equal(localization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
63
237
  assert.equal(localization.getLocalizedString("FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
64
238
  });
239
+ it("first level with substitution with fallback keys", () => {
240
+ assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
241
+ assert.equal(localization.getLocalizedString(["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
242
+ assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
243
+ });
65
244
  it("second level with substitution", () => {
66
245
  assert.equal(localization.getLocalizedString("SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
67
246
  assert.equal(localization.getLocalizedString("SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
68
247
  });
248
+ it("second level with substitution with fallback keys", () => {
249
+ assert.equal(localization.getLocalizedString(["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
250
+ assert.equal(localization.getLocalizedString(["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
251
+ });
69
252
  it("first level missing key doesn't find a value", () => {
70
253
  assert.equal(localization.getLocalizedString("MissingKeyString"), "MissingKeyString");
71
254
  });
255
+ it("first level missing all keys doesn't find a value", () => {
256
+ assert.equal(localization.getLocalizedString(["MissingKeyString", "MissingString2"]), "MissingString2");
257
+ });
72
258
  it("second level missing key doesn't find a value", () => {
73
259
  assert.equal(localization.getLocalizedString("SecondTrivial.MissingString"), "SecondTrivial.MissingString");
74
- assert.equal(localization.getLocalizedString("MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
260
+ assert.equal(localization.getLocalizedString(["NotExist", "MissingKeyObject.MissingString"]), "MissingKeyObject.MissingString");
261
+ });
262
+ it("read from en-US fallback", () => {
263
+ assert.equal(localization.getLocalizedString("OnlyEnglishUS"), "HelloUS");
264
+ });
265
+ });
266
+ describe("Default Namespace (German)", () => {
267
+ it("first level with no substitution", () => {
268
+ assert.equal(germanLocalization.getLocalizedString("FirstTrivial"), "First level string (default german)");
269
+ });
270
+ it("first level with no substitution with fallback keys", () => {
271
+ assert.equal(germanLocalization.getLocalizedString(["FirstTrivial", "NotExist"]), "First level string (default german)");
272
+ assert.equal(germanLocalization.getLocalizedString(["NotExist", "FirstTrivial"]), "First level string (default german)");
273
+ });
274
+ it("second level with no substitution", () => {
275
+ assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test1"), "Second level string 1 (default german)");
276
+ assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test2"), "Second level string 2 (default german)");
277
+ });
278
+ it("second level with no substitution with fallback keys", () => {
279
+ assert.equal(germanLocalization.getLocalizedString(["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default german)");
280
+ assert.equal(germanLocalization.getLocalizedString(["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (default german)");
281
+ });
282
+ it("first level with substitution", () => {
283
+ assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
284
+ assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
285
+ assert.equal(germanLocalization.getLocalizedString("FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
286
+ });
287
+ it("first level with substitution with fallback keys", () => {
288
+ assert.equal(germanLocalization.getLocalizedString(["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
289
+ assert.equal(germanLocalization.getLocalizedString(["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
290
+ assert.equal(germanLocalization.getLocalizedString(["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
291
+ });
292
+ it("second level with substitution", () => {
293
+ assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
294
+ assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
295
+ });
296
+ it("second level with substitution with fallback keys", () => {
297
+ assert.equal(germanLocalization.getLocalizedString(["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
298
+ assert.equal(germanLocalization.getLocalizedString(["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
299
+ });
300
+ it("first level missing key doesn't find a value", () => {
301
+ assert.equal(germanLocalization.getLocalizedString("MissingKeyString"), "MissingKeyString");
302
+ });
303
+ it("first level missing all keys doesn't find a value", () => {
304
+ assert.equal(germanLocalization.getLocalizedString(["MissingKeyString", "MissingString2"]), "MissingString2");
305
+ });
306
+ it("second level missing key doesn't find a value", () => {
307
+ assert.equal(germanLocalization.getLocalizedString("SecondTrivial.MissingString"), "SecondTrivial.MissingString");
308
+ assert.equal(germanLocalization.getLocalizedString("MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
75
309
  });
76
310
  });
77
311
  describe("Given Namespace", () => {
@@ -79,12 +313,20 @@ describe("ITwinLocalization", () => {
79
313
  assert.equal(localization.getLocalizedString("Default:FirstTrivial"), "First level string (default)");
80
314
  assert.equal(localization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
81
315
  });
316
+ it("first level with no substitution with fallback keys", () => {
317
+ assert.equal(localization.getLocalizedString(["Default:FirstTrivial", "Not:NotExist"]), "First level string (default)");
318
+ assert.equal(localization.getLocalizedString(["Default:NotExist", "Test:FirstTrivial"]), "First level string (test)");
319
+ });
82
320
  it("second level with no substitution", () => {
83
321
  assert.equal(localization.getLocalizedString("Default:SecondTrivial.Test1"), "Second level string 1 (default)");
84
322
  assert.equal(localization.getLocalizedString("Default:SecondTrivial.Test2"), "Second level string 2 (default)");
85
323
  assert.equal(localization.getLocalizedString("Test:SecondTrivial.Test1"), "Second level string 1 (test)");
86
324
  assert.equal(localization.getLocalizedString("Test:SecondTrivial.Test2"), "Second level string 2 (test)");
87
325
  });
326
+ it("second level with no substitution with fallback keys", () => {
327
+ assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:SecondTrivial.Test1"]), "Second level string 1 (default)");
328
+ assert.equal(localization.getLocalizedString(["Test:SecondTrivial.Test2", "NotExist"]), "Second level string 2 (test)");
329
+ });
88
330
  it("first level with substitution", () => {
89
331
  assert.equal(localization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
90
332
  assert.equal(localization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
@@ -93,12 +335,21 @@ describe("ITwinLocalization", () => {
93
335
  assert.equal(localization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
94
336
  assert.equal(localization.getLocalizedString("Test:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
95
337
  });
338
+ it("first level with substitution with fallback keys", () => {
339
+ assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
340
+ assert.equal(localization.getLocalizedString(["Test:FirstSubstitution1", "Default:NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
341
+ assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
342
+ });
96
343
  it("second level with substitution", () => {
97
344
  assert.equal(localization.getLocalizedString("Default:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
98
345
  assert.equal(localization.getLocalizedString("Default:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
99
346
  assert.equal(localization.getLocalizedString("Test:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
100
347
  assert.equal(localization.getLocalizedString("Test:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
101
348
  });
349
+ it("second level with substitution with fallback keys", () => {
350
+ assert.equal(localization.getLocalizedString(["Test:NotExist", "Default:SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
351
+ assert.equal(localization.getLocalizedString(["Test:SecondSubstitution.Test2", "Default:NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
352
+ });
102
353
  it("first level missing key doesn't find a value", () => {
103
354
  assert.equal(localization.getLocalizedString("Default:MissingKeyString"), "MissingKeyString");
104
355
  assert.equal(localization.getLocalizedString("Test:MissingKeyString"), "MissingKeyString");
@@ -107,6 +358,43 @@ describe("ITwinLocalization", () => {
107
358
  assert.equal(localization.getLocalizedString("Test:SecondTrivial.MissingString"), "SecondTrivial.MissingString");
108
359
  assert.equal(localization.getLocalizedString("Test:MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
109
360
  });
361
+ it("read from en-US fallback", () => {
362
+ assert.equal(localization.getLocalizedString("Default:OnlyEnglishUS"), "HelloUS");
363
+ });
364
+ });
365
+ describe("Given Namespace (German)", () => {
366
+ it("first level with no substitution", () => {
367
+ assert.equal(germanLocalization.getLocalizedString("Default:FirstTrivial"), "First level string (default german)");
368
+ assert.equal(germanLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (german)");
369
+ });
370
+ it("second level with no substitution", () => {
371
+ assert.equal(germanLocalization.getLocalizedString("Default:SecondTrivial.Test1"), "Second level string 1 (default german)");
372
+ assert.equal(germanLocalization.getLocalizedString("Default:SecondTrivial.Test2"), "Second level string 2 (default german)");
373
+ assert.equal(germanLocalization.getLocalizedString("Test:SecondTrivial.Test1"), "Second level string 1 (german)");
374
+ assert.equal(germanLocalization.getLocalizedString("Test:SecondTrivial.Test2"), "Second level string 2 (german)");
375
+ });
376
+ it("first level with substitution", () => {
377
+ assert.equal(germanLocalization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
378
+ assert.equal(germanLocalization.getLocalizedString("Default:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
379
+ assert.equal(germanLocalization.getLocalizedString("Default:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
380
+ assert.equal(germanLocalization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (german)");
381
+ assert.equal(germanLocalization.getLocalizedString("Test:FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (german)");
382
+ assert.equal(germanLocalization.getLocalizedString("Test:FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (german)");
383
+ });
384
+ it("second level with substitution", () => {
385
+ assert.equal(germanLocalization.getLocalizedString("Default:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
386
+ assert.equal(germanLocalization.getLocalizedString("Default:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
387
+ assert.equal(germanLocalization.getLocalizedString("Test:SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (german)");
388
+ assert.equal(germanLocalization.getLocalizedString("Test:SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (german)");
389
+ });
390
+ it("first level missing key doesn't find a value", () => {
391
+ assert.equal(germanLocalization.getLocalizedString("Default:MissingKeyString"), "MissingKeyString");
392
+ assert.equal(germanLocalization.getLocalizedString("Test:MissingKeyString"), "MissingKeyString");
393
+ });
394
+ it("second level missing key doesn't find a value", () => {
395
+ assert.equal(germanLocalization.getLocalizedString("Test:SecondTrivial.MissingString"), "SecondTrivial.MissingString");
396
+ assert.equal(germanLocalization.getLocalizedString("Test:MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
397
+ });
110
398
  });
111
399
  describe("Nonexisting Namespace", () => {
112
400
  it("first level fails", () => {
@@ -117,7 +405,463 @@ describe("ITwinLocalization", () => {
117
405
  assert.equal(localization.getLocalizedString("Nonexisting:SecondTrivial.Test1"), "SecondTrivial.Test1");
118
406
  assert.equal(localization.getLocalizedString("Nonexisting:Missing.String"), "Missing.String");
119
407
  });
408
+ it("fallback key fails", () => {
409
+ assert.equal(localization.getLocalizedString(["Nonexisting:FirstTrivial", "NotExist"]), "NotExist");
410
+ assert.equal(localization.getLocalizedString(["NotExist", "Nonexisting:Missing.String"]), "Missing.String");
411
+ });
412
+ });
413
+ // Test a few options to make sure they get passed through correctly
414
+ describe("With Options", () => {
415
+ it("returnDetails throws error", () => {
416
+ assert.throws(() => {
417
+ localization.getLocalizedString("X", { returnDetails: true });
418
+ }, "Translation key must map to a string, but the given options will result in an object");
419
+ });
420
+ it("returnObjects throws error", () => {
421
+ assert.throws(() => {
422
+ localization.getLocalizedString("X", { returnObjects: true });
423
+ }, "Translation key must map to a string, but the given options will result in an object");
424
+ });
425
+ it("returnDetails and returnObjects throws error", () => {
426
+ assert.throws(() => {
427
+ localization.getLocalizedString("X", { returnDetails: true, returnObjects: true });
428
+ }, "Translation key must map to a string, but the given options will result in an object");
429
+ });
430
+ it("default value", () => {
431
+ assert.equal(localization.getLocalizedString("Missing", { defaultValue: "default" }), "default");
432
+ });
433
+ it("override fallback language", () => {
434
+ // Doesn't fallback to English
435
+ assert.equal(germanLocalization.getLocalizedString("OnlyEnglish", { fallbackLng: "de" }), "OnlyEnglish");
436
+ });
437
+ it("set namespace", () => {
438
+ assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Test" }), "First level string (test)");
439
+ assert.equal(localization.getLocalizedString("FirstSubstitution1", { str: "CUSTOM1", ns: "Test" }), "First level CUSTOM1 (test)");
440
+ });
441
+ });
442
+ });
443
+ describe("#getLocalizedString with namespace passed in as an option", () => {
444
+ before(async () => {
445
+ localization = new ITwinLocalization();
446
+ await localization.initialize(["Default", "Test"]);
447
+ germanLocalization = new ITwinLocalization({ initOptions: { lng: "de" } });
448
+ await germanLocalization.initialize(["Default", "Test"]);
449
+ });
450
+ describe("Keys Without Namespaces", () => {
451
+ it("first level with no substitution", () => {
452
+ assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Default" }), "First level string (default)");
453
+ assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Test" }), "First level string (test)");
454
+ });
455
+ it("first level with no substitution with fallback keys", () => {
456
+ assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist"], { ns: "Default" }), "First level string (default)");
457
+ assert.equal(localization.getLocalizedString(["NotExist", "FirstTrivial"], { ns: "Test" }), "First level string (test)");
458
+ });
459
+ it("second level with no substitution", () => {
460
+ assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "Default" }), "Second level string 1 (default)");
461
+ assert.equal(localization.getLocalizedString("SecondTrivial.Test2", { ns: "Default" }), "Second level string 2 (default)");
462
+ assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "Test" }), "Second level string 1 (test)");
463
+ assert.equal(localization.getLocalizedString("SecondTrivial.Test2", { ns: "Test" }), "Second level string 2 (test)");
464
+ });
465
+ it("second level with no substitution with fallback keys", () => {
466
+ assert.equal(localization.getLocalizedString(["NotExist", "SecondTrivial.Test1"], { ns: "Default" }), "Second level string 1 (default)");
467
+ assert.equal(localization.getLocalizedString(["SecondTrivial.Test2", "NotExist"], { ns: "Test" }), "Second level string 2 (test)");
468
+ });
469
+ it("first level with substitution", () => {
470
+ assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM1" }), "First level CUSTOM1 (default)");
471
+ assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM2" }), "First level CUSTOM2 (default)");
472
+ assert.equal(localization.getLocalizedString("FirstSubstitution2", { ns: "Default", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
473
+ assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM1" }), "First level CUSTOM1 (test)");
474
+ assert.equal(localization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM2" }), "First level CUSTOM2 (test)");
475
+ assert.equal(localization.getLocalizedString("FirstSubstitution2", { ns: "Test", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
476
+ });
477
+ it("first level with substitution with fallback keys", () => {
478
+ assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution1"], { ns: "Default", str: "CUSTOM1" }), "First level CUSTOM1 (default)");
479
+ assert.equal(localization.getLocalizedString(["FirstSubstitution1", "NotExist"], { ns: "Test", str: "CUSTOM2" }), "First level CUSTOM2 (test)");
480
+ assert.equal(localization.getLocalizedString(["NotExist", "FirstSubstitution2"], { ns: "Test", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
481
+ });
482
+ it("second level with substitution", () => {
483
+ assert.equal(localization.getLocalizedString("SecondSubstitution.Test1", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
484
+ assert.equal(localization.getLocalizedString("SecondSubstitution.Test2", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
485
+ assert.equal(localization.getLocalizedString("SecondSubstitution.Test1", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
486
+ assert.equal(localization.getLocalizedString("SecondSubstitution.Test2", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
487
+ });
488
+ it("second level with substitution with fallback keys", () => {
489
+ assert.equal(localization.getLocalizedString(["NotExist", "SecondSubstitution.Test1"], { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
490
+ assert.equal(localization.getLocalizedString(["SecondSubstitution.Test2", "NotExist"], { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
491
+ });
492
+ it("first level missing key doesn't find a value", () => {
493
+ assert.equal(localization.getLocalizedString("MissingKeyString", { ns: "Default" }), "MissingKeyString");
494
+ assert.equal(localization.getLocalizedString("MissingKeyString", { ns: "Test" }), "MissingKeyString");
495
+ });
496
+ it("second level missing key doesn't find a value", () => {
497
+ assert.equal(localization.getLocalizedString("SecondTrivial.MissingString", { ns: "Test" }), "SecondTrivial.MissingString");
498
+ assert.equal(localization.getLocalizedString("MissingKeyObject.MissingString", { ns: "Test" }), "MissingKeyObject.MissingString");
499
+ });
500
+ });
501
+ describe("Keys Without Namespaces (German)", () => {
502
+ it("first level with no substitution", () => {
503
+ assert.equal(germanLocalization.getLocalizedString("FirstTrivial", { ns: "Default" }), "First level string (default german)");
504
+ assert.equal(germanLocalization.getLocalizedString("FirstTrivial", { ns: "Test" }), "First level string (german)");
505
+ });
506
+ it("second level with no substitution", () => {
507
+ assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test1", { ns: "Default" }), "Second level string 1 (default german)");
508
+ assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test2", { ns: "Default" }), "Second level string 2 (default german)");
509
+ assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test1", { ns: "Test" }), "Second level string 1 (german)");
510
+ assert.equal(germanLocalization.getLocalizedString("SecondTrivial.Test2", { ns: "Test" }), "Second level string 2 (german)");
511
+ });
512
+ it("first level with substitution", () => {
513
+ assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM1" }), "First level CUSTOM1 (default german)");
514
+ assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Default", str: "CUSTOM2" }), "First level CUSTOM2 (default german)");
515
+ assert.equal(germanLocalization.getLocalizedString("FirstSubstitution2", { ns: "Default", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default german)");
516
+ assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM1" }), "First level CUSTOM1 (german)");
517
+ assert.equal(germanLocalization.getLocalizedString("FirstSubstitution1", { ns: "Test", str: "CUSTOM2" }), "First level CUSTOM2 (german)");
518
+ assert.equal(germanLocalization.getLocalizedString("FirstSubstitution2", { ns: "Test", str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (german)");
519
+ });
520
+ it("second level with substitution", () => {
521
+ assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test1", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default german)");
522
+ assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test2", { ns: "Default", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default german)");
523
+ assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test1", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (german)");
524
+ assert.equal(germanLocalization.getLocalizedString("SecondSubstitution.Test2", { ns: "Test", varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (german)");
525
+ });
526
+ it("first level missing key doesn't find a value", () => {
527
+ assert.equal(germanLocalization.getLocalizedString("MissingKeyString", { ns: "Default" }), "MissingKeyString");
528
+ assert.equal(germanLocalization.getLocalizedString("MissingKeyString", { ns: "Test" }), "MissingKeyString");
529
+ });
530
+ it("second level missing key doesn't find a value", () => {
531
+ assert.equal(germanLocalization.getLocalizedString("SecondTrivial.MissingString", { ns: "Test" }), "SecondTrivial.MissingString");
532
+ assert.equal(germanLocalization.getLocalizedString("MissingKeyObject.MissingString", { ns: "Test" }), "MissingKeyObject.MissingString");
533
+ });
534
+ });
535
+ describe("Keys With Namespaces", () => {
536
+ it("key with same namespace works", () => {
537
+ assert.equal(localization.getLocalizedString("Default:FirstTrivial", { ns: "Default" }), "First level string (default)");
538
+ assert.equal(localization.getLocalizedString("Test:SecondTrivial.Test1", { ns: "Test" }), "Second level string 1 (test)");
539
+ });
540
+ it("key with different namespace overrides given namespace", () => {
541
+ assert.equal(localization.getLocalizedString("Test:FirstTrivial", { ns: "Default" }), "First level string (test)");
542
+ assert.equal(localization.getLocalizedString("Default:FirstTrivial", { ns: "Test" }), "First level string (default)");
543
+ });
544
+ it("key with same namespace works with fallback keys", () => {
545
+ assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Default:FirstTrivial"], { ns: "Default" }), "First level string (default)");
546
+ assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Test:FirstTrivial"], { ns: "Test" }), "First level string (test)");
547
+ });
548
+ it("key with different namespace overrides given namespace with fallback keys", () => {
549
+ assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Test:FirstTrivial"], { ns: "Default" }), "First level string (test)");
550
+ assert.equal(localization.getLocalizedString(["NotExist:FirstTrivial", "Default:FirstTrivial"], { ns: "Test" }), "First level string (default)");
551
+ });
552
+ it("missing key does not find a value", () => {
553
+ assert.equal(germanLocalization.getLocalizedString("Default:MissingKeyString", { ns: "Default" }), "MissingKeyString");
554
+ assert.equal(germanLocalization.getLocalizedString(["Missing1", "MissingKeyObject.MissingString"], { ns: "Test" }), "MissingKeyObject.MissingString");
555
+ });
556
+ });
557
+ describe("Nonexisting Namespace", () => {
558
+ it("first level fails", () => {
559
+ assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "Nonexisting" }), "FirstTrivial");
560
+ assert.equal(localization.getLocalizedString("MissingKeyString", { ns: "Nonexisting" }), "MissingKeyString");
561
+ });
562
+ it("second level fails", () => {
563
+ assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "Nonexisting" }), "SecondTrivial.Test1");
564
+ assert.equal(localization.getLocalizedString("Missing.String", { ns: "Nonexisting" }), "Missing.String");
565
+ });
566
+ it("empty string namespace falls back to default namespace", () => {
567
+ assert.equal(localization.getLocalizedString("FirstTrivial", { ns: "" }), "First level string (default)");
568
+ assert.equal(localization.getLocalizedString("SecondTrivial.Test1", { ns: "" }), "Second level string 1 (default)");
569
+ });
570
+ it("fallback key fails", () => {
571
+ assert.equal(localization.getLocalizedString(["FirstTrivial", "NotExist"], { ns: "Nonexisting" }), "NotExist");
572
+ assert.equal(localization.getLocalizedString(["NotExist", "Missing.String"], { ns: "Nonexisting" }), "Missing.String");
573
+ });
574
+ it("use key with valid namespace instead", () => {
575
+ assert.equal(localization.getLocalizedString("Default:FirstTrivial", { ns: "Nonexisting" }), "First level string (default)");
576
+ assert.equal(localization.getLocalizedString("Test:FirstTrivial", { ns: "Nonexisting" }), "First level string (test)");
577
+ });
578
+ it("providing key with invalid namespace fails", () => {
579
+ assert.equal(localization.getLocalizedString("Nonexisting2:FirstTrivial", { ns: "Nonexisting1" }), "FirstTrivial");
580
+ });
581
+ });
582
+ // Test a few options to make sure they get passed through correctly
583
+ describe("With Options", () => {
584
+ it("returnDetails throws error", () => {
585
+ assert.throws(() => {
586
+ localization.getLocalizedString("X", { ns: "Default", returnDetails: true });
587
+ }, "Translation key must map to a string, but the given options will result in an object");
588
+ });
589
+ it("returnObjects throws error", () => {
590
+ assert.throws(() => {
591
+ localization.getLocalizedString("X", { ns: "Default", returnObjects: true });
592
+ }, "Translation key must map to a string, but the given options will result in an object");
593
+ });
594
+ it("returnDetails and returnObjects throws error", () => {
595
+ assert.throws(() => {
596
+ localization.getLocalizedString("X", { ns: "Default", returnDetails: true, returnObjects: true });
597
+ }, "Translation key must map to a string, but the given options will result in an object");
598
+ });
599
+ it("default value", () => {
600
+ assert.equal(localization.getLocalizedString("Missing", { ns: "Default", defaultValue: "default" }), "default");
601
+ });
602
+ it("override fallback language", () => {
603
+ // Doesn't fallback to English
604
+ assert.equal(germanLocalization.getLocalizedString("OnlyEnglish", { ns: "Default", fallbackLng: "de" }), "OnlyEnglish");
605
+ });
606
+ });
607
+ });
608
+ describe("#getEnglishString", () => {
609
+ before(async () => {
610
+ localization = new ITwinLocalization();
611
+ await localization.initialize(["Default", "Test"]);
612
+ germanLocalization = new ITwinLocalization({ initOptions: { lng: "de" } });
613
+ await germanLocalization.initialize(["Default", "Test"]);
614
+ });
615
+ describe("Given Namespace", () => {
616
+ it("first level with no substitution", () => {
617
+ assert.equal(localization.getEnglishString("Default", "FirstTrivial"), "First level string (default)");
618
+ assert.equal(localization.getEnglishString("Test", "FirstTrivial"), "First level string (test)");
619
+ });
620
+ it("first level with no substitution with fallback keys", () => {
621
+ assert.equal(localization.getEnglishString("Default", ["FirstTrivial", "NotExist"]), "First level string (default)");
622
+ assert.equal(localization.getEnglishString("Test", ["NotExist", "FirstTrivial"]), "First level string (test)");
623
+ });
624
+ it("second level with no substitution", () => {
625
+ assert.equal(localization.getEnglishString("Default", "SecondTrivial.Test1"), "Second level string 1 (default)");
626
+ assert.equal(localization.getEnglishString("Default", "SecondTrivial.Test2"), "Second level string 2 (default)");
627
+ assert.equal(localization.getEnglishString("Test", "SecondTrivial.Test1"), "Second level string 1 (test)");
628
+ assert.equal(localization.getEnglishString("Test", "SecondTrivial.Test2"), "Second level string 2 (test)");
629
+ });
630
+ it("second level with no substitution with fallback keys", () => {
631
+ assert.equal(localization.getEnglishString("Default", ["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default)");
632
+ assert.equal(localization.getEnglishString("Test", ["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (test)");
633
+ });
634
+ it("first level with substitution", () => {
635
+ assert.equal(localization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
636
+ assert.equal(localization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
637
+ assert.equal(localization.getEnglishString("Default", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
638
+ assert.equal(localization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (test)");
639
+ assert.equal(localization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
640
+ assert.equal(localization.getEnglishString("Test", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
641
+ });
642
+ it("first level with substitution with fallback keys", () => {
643
+ assert.equal(localization.getEnglishString("Default", ["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
644
+ assert.equal(localization.getEnglishString("Test", ["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
645
+ assert.equal(localization.getEnglishString("Test", ["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
646
+ });
647
+ it("second level with substitution", () => {
648
+ assert.equal(localization.getEnglishString("Default", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
649
+ assert.equal(localization.getEnglishString("Default", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
650
+ assert.equal(localization.getEnglishString("Test", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
651
+ assert.equal(localization.getEnglishString("Test", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
652
+ });
653
+ it("second level with substitution with fallback keys", () => {
654
+ assert.equal(localization.getEnglishString("Default", ["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
655
+ assert.equal(localization.getEnglishString("Test", ["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
656
+ });
657
+ it("first level missing key doesn't find a value", () => {
658
+ assert.equal(localization.getEnglishString("Default", "MissingKeyString"), "MissingKeyString");
659
+ assert.equal(localization.getEnglishString("Test", "MissingKeyString"), "MissingKeyString");
660
+ });
661
+ it("second level missing key doesn't find a value", () => {
662
+ assert.equal(localization.getEnglishString("Test", "SecondTrivial.MissingString"), "SecondTrivial.MissingString");
663
+ assert.equal(localization.getEnglishString("Test", "MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
664
+ });
665
+ });
666
+ describe("Given Namespace with German default language returns English strings", () => {
667
+ it("first level with no substitution", () => {
668
+ assert.equal(germanLocalization.getEnglishString("Default", "FirstTrivial"), "First level string (default)");
669
+ assert.equal(germanLocalization.getEnglishString("Test", "FirstTrivial"), "First level string (test)");
670
+ });
671
+ it("first level with no substitution with fallback keys", () => {
672
+ assert.equal(germanLocalization.getEnglishString("Default", ["FirstTrivial", "NotExist"]), "First level string (default)");
673
+ assert.equal(germanLocalization.getEnglishString("Test", ["NotExist", "FirstTrivial"]), "First level string (test)");
674
+ });
675
+ it("second level with no substitution", () => {
676
+ assert.equal(germanLocalization.getEnglishString("Default", "SecondTrivial.Test1"), "Second level string 1 (default)");
677
+ assert.equal(germanLocalization.getEnglishString("Default", "SecondTrivial.Test2"), "Second level string 2 (default)");
678
+ assert.equal(germanLocalization.getEnglishString("Test", "SecondTrivial.Test1"), "Second level string 1 (test)");
679
+ assert.equal(germanLocalization.getEnglishString("Test", "SecondTrivial.Test2"), "Second level string 2 (test)");
680
+ });
681
+ it("second level with no substitution with fallback keys", () => {
682
+ assert.equal(germanLocalization.getEnglishString("Default", ["NotExist", "SecondTrivial.Test1"]), "Second level string 1 (default)");
683
+ assert.equal(germanLocalization.getEnglishString("Test", ["SecondTrivial.Test2", "NotExist"]), "Second level string 2 (test)");
684
+ });
685
+ it("first level with substitution", () => {
686
+ assert.equal(germanLocalization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
687
+ assert.equal(germanLocalization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (default)");
688
+ assert.equal(germanLocalization.getEnglishString("Default", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (default)");
689
+ assert.equal(germanLocalization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM1" }), "First level CUSTOM1 (test)");
690
+ assert.equal(germanLocalization.getEnglishString("Test", "FirstSubstitution1", { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
691
+ assert.equal(germanLocalization.getEnglishString("Test", "FirstSubstitution2", { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
692
+ });
693
+ it("first level with substitution with fallback keys", () => {
694
+ assert.equal(germanLocalization.getEnglishString("Default", ["NotExist", "FirstSubstitution1"], { str: "CUSTOM1" }), "First level CUSTOM1 (default)");
695
+ assert.equal(germanLocalization.getEnglishString("Test", ["FirstSubstitution1", "NotExist"], { str: "CUSTOM2" }), "First level CUSTOM2 (test)");
696
+ assert.equal(germanLocalization.getEnglishString("Test", ["NotExist", "FirstSubstitution2"], { str1: "CUSTOM1", str2: "CUSTOM2" }), "First level CUSTOM1 and CUSTOM2 (test)");
697
+ });
698
+ it("second level with substitution", () => {
699
+ assert.equal(germanLocalization.getEnglishString("Default", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
700
+ assert.equal(germanLocalization.getEnglishString("Default", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (default)");
701
+ assert.equal(germanLocalization.getEnglishString("Test", "SecondSubstitution.Test1", { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (test)");
702
+ assert.equal(germanLocalization.getEnglishString("Test", "SecondSubstitution.Test2", { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
703
+ });
704
+ it("second level with substitution with fallback keys", () => {
705
+ assert.equal(germanLocalization.getEnglishString("Default", ["NotExist", "SecondSubstitution.Test1"], { varA: "Variable1", varB: "Variable2" }), "Substitute Variable1 and Variable2 (default)");
706
+ assert.equal(germanLocalization.getEnglishString("Test", ["SecondSubstitution.Test2", "NotExist"], { varA: "Variable1", varB: "Variable2" }), "Reverse substitute Variable2 and Variable1 (test)");
707
+ });
708
+ it("first level missing key doesn't find a value", () => {
709
+ assert.equal(germanLocalization.getEnglishString("Default", "MissingKeyString"), "MissingKeyString");
710
+ assert.equal(germanLocalization.getEnglishString("Test", "MissingKeyString"), "MissingKeyString");
711
+ });
712
+ it("second level missing key doesn't find a value", () => {
713
+ assert.equal(germanLocalization.getEnglishString("Test", "SecondTrivial.MissingString"), "SecondTrivial.MissingString");
714
+ assert.equal(germanLocalization.getEnglishString("Test", "MissingKeyObject.MissingString"), "MissingKeyObject.MissingString");
715
+ });
716
+ });
717
+ describe("Nonexisting Namespace", () => {
718
+ it("first level fails", () => {
719
+ assert.equal(localization.getEnglishString("Nonexisting", "FirstTrivial"), "FirstTrivial");
720
+ assert.equal(localization.getEnglishString("Nonexisting", "MissingKeyString"), "MissingKeyString");
721
+ });
722
+ it("second level fails", () => {
723
+ assert.equal(localization.getEnglishString("Nonexisting", "SecondTrivial.Test1"), "SecondTrivial.Test1");
724
+ assert.equal(localization.getEnglishString("Nonexisting", "Missing.String"), "Missing.String");
725
+ });
726
+ it("empty string namespace is treated as default namespace", () => {
727
+ assert.equal(localization.getEnglishString("", "FirstTrivial"), "First level string (default)");
728
+ assert.equal(localization.getEnglishString("", "SecondTrivial.Test1"), "Second level string 1 (default)");
729
+ });
730
+ });
731
+ // Test a few options to make sure they get passed through correctly
732
+ describe("With Options", () => {
733
+ it("returnDetails throws error", () => {
734
+ assert.throws(() => {
735
+ localization.getEnglishString("Default", "X", { returnDetails: true });
736
+ }, "Translation key must map to a string, but the given options will result in an object");
737
+ });
738
+ it("returnObjects throws error", () => {
739
+ assert.throws(() => {
740
+ localization.getEnglishString("Default", "X", { returnObjects: true });
741
+ }, "Translation key must map to a string, but the given options will result in an object");
742
+ });
743
+ it("returnDetails and returnObjects throws error", () => {
744
+ assert.throws(() => {
745
+ localization.getEnglishString("Default", "X", { returnDetails: true, returnObjects: true });
746
+ }, "Translation key must map to a string, but the given options will result in an object");
747
+ });
748
+ it("default value", () => {
749
+ assert.equal(localization.getEnglishString("Default", "Missing", { defaultValue: "default" }), "default");
750
+ });
751
+ it("english takes priority over fallback language", () => {
752
+ assert.equal(germanLocalization.getEnglishString("Default", "OnlyEnglish", { fallbackLng: "de" }), "Hello");
753
+ });
754
+ // White box test
755
+ it("given namespace overrides namespace translation option", () => {
756
+ assert.equal(localization.getEnglishString("Default", "FirstTrivial", { ns: "Test" }), "First level string (default)");
757
+ assert.equal(localization.getEnglishString("Default", "FirstSubstitution1", { str: "CUSTOM1", ns: "Test" }), "First level CUSTOM1 (default)");
758
+ });
759
+ });
760
+ });
761
+ // Returned promises never have anything of substance, being only empty or resolving to null...
762
+ // describe("#getNamespacePromise", () => {
763
+ // });
764
+ describe("#getLanguageList", () => {
765
+ let languages;
766
+ it("english language list includes en and en-US", async () => {
767
+ localization = new ITwinLocalization();
768
+ await localization.initialize([]);
769
+ languages = localization.getLanguageList();
770
+ assert.isTrue(languages.includes("en-US"));
771
+ assert.isTrue(languages.includes("en"));
772
+ });
773
+ it("when non-english language is set as default, that language and english are included in langauge list", async () => {
774
+ germanLocalization = new ITwinLocalization({ initOptions: { lng: "de" } });
775
+ await germanLocalization.initialize([]);
776
+ languages = germanLocalization.getLanguageList();
777
+ assert.isTrue(languages.includes("en"));
778
+ assert.isTrue(languages.includes("de"));
779
+ });
780
+ });
781
+ describe("#changeLanguage", () => {
782
+ it("change from english to another language", async () => {
783
+ localization = new ITwinLocalization();
784
+ await localization.initialize(["Default"]);
785
+ assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default)"); // english
786
+ await localization.changeLanguage("de");
787
+ assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default german)"); // german
788
+ });
789
+ it("change from another language to english", async () => {
790
+ localization = new ITwinLocalization({ initOptions: { lng: "de" } });
791
+ await localization.initialize(["Default"]);
792
+ assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default german)"); // german
793
+ await localization.changeLanguage("en");
794
+ assert.equal(localization.getLocalizedString("FirstTrivial"), "First level string (default)"); // english
795
+ });
796
+ });
797
+ describe("#registerNamespace", () => {
798
+ let itwinLocalization;
799
+ beforeEach(async () => {
800
+ itwinLocalization = new ITwinLocalization();
801
+ });
802
+ it("can read from namespace after it is registered", async () => {
803
+ await itwinLocalization.initialize([]);
804
+ await itwinLocalization.registerNamespace("Test");
805
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("Test"));
806
+ assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
807
+ });
808
+ it("zero initial, register one", async () => {
809
+ await itwinLocalization.initialize([]);
810
+ await itwinLocalization.registerNamespace("test1");
811
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
812
+ });
813
+ it("zero initial, register two", async () => {
814
+ await itwinLocalization.initialize([]);
815
+ await itwinLocalization.registerNamespace("test1");
816
+ await itwinLocalization.registerNamespace("test2");
817
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
818
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test2"));
819
+ });
820
+ it("one initial, register one", async () => {
821
+ await itwinLocalization.initialize(["initial1"]);
822
+ await itwinLocalization.registerNamespace("test1");
823
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
824
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
825
+ });
826
+ it("one initial, register two", async () => {
827
+ await itwinLocalization.initialize(["initial1"]);
828
+ await itwinLocalization.registerNamespace("test1");
829
+ await itwinLocalization.registerNamespace("test2");
830
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
831
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test2"));
832
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
833
+ });
834
+ it("two initial, register one", async () => {
835
+ await itwinLocalization.initialize(["initial1", "initial2"]);
836
+ await itwinLocalization.registerNamespace("test1");
837
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
838
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
839
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial2"));
840
+ });
841
+ it("two initial, register two", async () => {
842
+ await itwinLocalization.initialize(["initial1", "initial2"]);
843
+ await itwinLocalization.registerNamespace("test1");
844
+ await itwinLocalization.registerNamespace("test2");
845
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("test1"));
846
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial1"));
847
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("initial2"));
848
+ });
849
+ it("register duplicate namespaces", async () => {
850
+ await itwinLocalization.initialize([]);
851
+ await itwinLocalization.registerNamespace("Test");
852
+ await itwinLocalization.registerNamespace("Test");
853
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("Test"));
854
+ assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
855
+ });
856
+ it("register duplicate namespace of initial namespace doesn't break anything", async () => {
857
+ await itwinLocalization.initialize(["Test"]);
858
+ await itwinLocalization.registerNamespace("Test");
859
+ assert.isTrue(itwinLocalization.i18next.hasLoadedNamespace("Test"));
860
+ assert.equal(itwinLocalization.getLocalizedString("Test:FirstTrivial"), "First level string (test)");
120
861
  });
121
862
  });
863
+ // unregisterNamespace() isn't used and basically does nothing
864
+ // describe("#unregisterNamespace", () => {
865
+ // });
122
866
  });
123
867
  //# sourceMappingURL=ITwinLocalization.test.js.map