@inlang/paraglide-js 2.26.0 → 2.28.0

package/dist/compiler/compile-message.test.js

@@ -1,5 +1,5 @@
 import { test, expect } from "vitest";
-import { compileMessage } from "./compile-message.js";
+import { compileMessage, } from "./compile-message.js";
 import { createRegistry } from "./registry.js";
 test("compiles a message with a single variant", async () => {
     const declarations = [];
@@ -84,7 +84,7 @@ test.each(["single", "multiple"])("compiles chained local variables in %s-varian
         });
     }
     const compiled = compileMessage(declarations, message, variants);
-    expect(compiled.code).toContain('const alpha = registry.number("en", zebra, {});');
+    expect(compiled.code).toContain('const alpha = registry.number("en", zebra, {}, true);');
     const { chained_locals } = await import("data:text/javascript;base64," +
         btoa(createRegistry() +
             "\nexport const chained_locals = " +
@@ -181,7 +181,7 @@ test("compiles pattern-level annotations to registry calls", async () => {
         },
     ];
     const compiled = compileMessage(declarations, message, variants);
-    expect(compiled.code).toContain('registry.number("en", i?.count, {})');
+    expect(compiled.code).toContain('registry.number("en", i?.count, {}, true)');
     const { views } = await import("data:text/javascript;base64," +
         // bundling the registry inline to avoid managing module imports here
         btoa(createRegistry() +
@@ -662,7 +662,7 @@ test("only emits input arguments when inputs exist", async () => {
 // https://github.com/opral/inlang-paraglide-js/issues/379
 test("compiles messages that use plural()", async () => {
     const declarations = [
-        { type: "input-variable", name: "date" },
+        { type: "input-variable", name: "count" },
         {
             type: "local-variable",
             name: "countPlural",
@@ -706,8 +706,9 @@ test("compiles messages that use plural()", async () => {
     const compiled = compileMessage(declarations, message, variants);
     const { plural_test } = await import("data:text/javascript;base64," +
         // bundling the registry inline to avoid managing module imports here
-        btoa(createRegistry()) +
-        btoa("export const plural_test = " + compiled.code.replace("registry.", "")));
+        btoa(createRegistry() +
+            "export const plural_test = " +
+            compiled.code.replace("registry.", "")));
     expect(plural_test({ count: 1 })).toBe("There is one cat.");
     expect(plural_test({ count: 2 })).toBe("There are many cats.");
     // INTL.plural will match "other" for undefined
@@ -790,8 +791,9 @@ test("compiles messages that use plural() with ordinal type", async () => {
     ];
     const compiled = compileMessage(declarations, message, variants);
     const { ordinal_test } = await import("data:text/javascript;base64," +
-        btoa(createRegistry()) +
-        btoa("export const ordinal_test = " + compiled.code.replace("registry.", "")));
+        btoa(createRegistry() +
+            "export const ordinal_test = " +
+            compiled.code.replace("registry.", "")));
     expect(ordinal_test({ count: 1 })).toBe("1st place");
     expect(ordinal_test({ count: 2 })).toBe("2nd place");
     expect(ordinal_test({ count: 3 })).toBe("3rd place");
@@ -839,8 +841,9 @@ test("compiles messages that use number()", async () => {
         const compiled = compileMessage(declarations, message, variants);
         const { number_test } = await import("data:text/javascript;base64," +
             // bundling the registry inline to avoid managing module imports here
-            btoa(createRegistry()) +
-            btoa("export const number_test = " + compiled.code.replace("registry.", "")));
+            btoa(createRegistry() +
+                "export const number_test = " +
+                compiled.code.replace("registry.", "")));
         return number_test;
     };
     const enMessage = await createMessage("en");
@@ -899,8 +902,9 @@ test("compiles messages that use number() with options", async () => {
         const compiled = compileMessage(declarations, message, variants);
         const { number_test } = await import("data:text/javascript;base64," +
             // bundling the registry inline to avoid managing module imports here
-            btoa(createRegistry()) +
-            btoa("export const number_test = " + compiled.code.replace("registry.", "")));
+            btoa(createRegistry() +
+                "export const number_test = " +
+                compiled.code.replace("registry.", "")));
         return number_test;
     };
     const enMessage = await createMessage("en");
@@ -950,15 +954,20 @@ test("compiles messages that use datetime()", async () => {
         const compiled = compileMessage(declarations, message, variants);
         const { datetime_test } = await import("data:text/javascript;base64," +
             // bundling the registry inline to avoid managing module imports here
-            btoa(createRegistry()) +
-            btoa("export const datetime_test =" +
+            btoa(createRegistry() +
+                "export const datetime_test =" +
                 compiled.code.replace("registry.", "")));
         return datetime_test;
     };
     const enMessage = await createMessage("en");
     const deMessage = await createMessage("de");
-    expect(enMessage({ date: "2022-04-01" })).toMatch(/Today is \d{1,2}\/\d{1,2}\/2022\./);
-    expect(deMessage({ date: "2022-04-01" })).toMatch(/Today is \d{1,2}\.\d{1,2}\.2022\./);
+    // MessageFormat 2's default: dateStyle=medium timeStyle=short. Compared
+    // with Intl to avoid the timezone affecting the unit test.
+    const date = new Date("2022-04-01");
+    const options = { dateStyle: "medium", timeStyle: "short" };
+    expect(enMessage({ date: "2022-04-01" })).toBe(`Today is ${new Intl.DateTimeFormat("en", options).format(date)}.`);
+    expect(enMessage({ date: "2022-04-01" })).toMatch(/Today is (Mar 31|Apr 1), 2022, \d{1,2}:\d{2}\s[AP]M\./);
+    expect(deMessage({ date: "2022-04-01" })).toBe(`Today is ${new Intl.DateTimeFormat("de", options).format(date)}.`);
 });
 test("compiles messages that use datetime a function with options", async () => {
     const createMessage = async (locale) => {
@@ -1005,8 +1014,8 @@ test("compiles messages that use datetime a function with options", async () =>
         const compiled = compileMessage(declarations, message, variants);
         const { datetime_test } = await import("data:text/javascript;base64," +
             // bundling the registry inline to avoid managing module imports here
-            btoa(createRegistry()) +
-            btoa("export const datetime_test = " +
+            btoa(createRegistry() +
+                "export const datetime_test = " +
                 compiled.code.replace("registry.", "")));
         return datetime_test;
     };
@@ -1062,8 +1071,8 @@ test("compiles messages that use relativetime() with options", async () => {
         const compiled = compileMessage(declarations, message, variants);
         const { relative_time_test } = await import("data:text/javascript;base64," +
             // bundling the registry inline to avoid managing module imports here
-            btoa(createRegistry()) +
-            btoa("export const relative_time_test = " +
+            btoa(createRegistry() +
+                "export const relative_time_test = " +
                 compiled.code.replace("registry.", "")));
         return relative_time_test;
     };
@@ -1120,8 +1129,8 @@ test("compiles messages that use relativetime() with dynamic units", async () =>
     const compiled = compileMessage(declarations, message, variants);
     const { relative_time_test } = await import("data:text/javascript;base64," +
         // bundling the registry inline to avoid managing module imports here
-        btoa(createRegistry()) +
-        btoa("export const relative_time_test = " +
+        btoa(createRegistry() +
+            "export const relative_time_test = " +
             compiled.code.replace("registry.", "")));
     expect(relative_time_test({ duration: -3, unit: "hour" })).toBe("Updated 3 hr. ago.");
 });
@@ -1187,4 +1196,86 @@ test("does not throw when input is omitted for multi-variant message", async ()
     expect(() => status_message()).not.toThrow();
     expect(status_message()).toBe("Unknown status");
 });
+// `selectBundleNested()` of `@inlang/sdk` 4 returns `bundle_id` on messages,
+// the plugin `Message` shape has `bundleId`. Without a catch-all variant, the
+// message falls back to the bundle id with either.
+test.each([
+    { shape: "plugin Message (bundleId)", ids: { bundleId: "item_count" } },
+    { shape: "database row (bundle_id)", ids: { bundle_id: "item_count" } },
+])("falls back to the bundle id for a $shape", async ({ ids }) => {
+    const declarations = [
+        { type: "input-variable", name: "count" },
+    ];
+    const message = {
+        ...ids,
+        id: "item_count_en",
+        locale: "en",
+        selectors: [{ type: "variable-reference", name: "count" }],
+    };
+    const variants = [
+        {
+            id: "item_count_en_one",
+            matches: [{ type: "literal-match", key: "count", value: "one" }],
+            pattern: [{ type: "text", value: "One item" }],
+        },
+        {
+            id: "item_count_en_two",
+            matches: [{ type: "literal-match", key: "count", value: "two" }],
+            pattern: [{ type: "text", value: "Two items" }],
+        },
+    ];
+    const markupVariants = [
+        {
+            id: "item_count_en_one",
+            matches: [{ type: "literal-match", key: "count", value: "one" }],
+            pattern: [
+                { type: "markup-start", name: "b" },
+                { type: "text", value: "One item" },
+                { type: "markup-end", name: "b" },
+            ],
+        },
+        {
+            id: "item_count_en_two",
+            matches: [{ type: "literal-match", key: "count", value: "two" }],
+            pattern: [{ type: "text", value: "Two items" }],
+        },
+    ];
+    const compiled = compileMessage(declarations, message, variants);
+    const compiledMarkup = compileMessage(declarations, message, markupVariants);
+    const { item_count, item_count_markup } = await import("data:text/javascript;base64," +
+        btoa(`export const item_count = ${compiled.code}\nexport const item_count_markup = ${compiledMarkup.code}`));
+    expect(item_count({ count: "one" })).toBe("One item");
+    expect(item_count({ count: "other" })).toBe("item_count");
+    expect(item_count_markup({ count: "other" })).toBe("item_count");
+    expect(item_count_markup.parts({ count: "other" })).toEqual([
+        { type: "text", value: "item_count" },
+    ]);
+});
+test("throws for a message without a bundle id instead of compiling undefined", () => {
+    expect(() => compileMessage([], { id: "orphan", locale: "en", selectors: [] }, [
+        { id: "1", matches: [], pattern: [{ type: "text", value: "Hi" }] },
+    ])).toThrow(/has no bundle id/);
+});
+test("escapes the bundle id in the fallback of messages without a catch-all variant", async () => {
+    const bundleId = 'quote"and\\backslash';
+    const compiled = compileMessage([{ type: "input-variable", name: "count" }], {
+        bundleId,
+        id: "m",
+        locale: "en",
+        selectors: [{ type: "variable-reference", name: "count" }],
+    }, [
+        {
+            id: "one",
+            matches: [{ type: "literal-match", key: "count", value: "one" }],
+            pattern: [{ type: "text", value: "One" }],
+        },
+        {
+            id: "two",
+            matches: [{ type: "literal-match", key: "count", value: "two" }],
+            pattern: [{ type: "text", value: "Two" }],
+        },
+    ]);
+    const { m } = await import("data:text/javascript;base64," + btoa(`export const m = ${compiled.code}`));
+    expect(m({ count: "three" })).toBe(bundleId);
+});
 //# sourceMappingURL=compile-message.test.js.map