@inlang/sdk 0.34.9 → 0.35.0

package/dist/loadProject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAkBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAYhD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CAiOzB;AA+GD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}
+{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAkBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAYhD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CAsOzB;AA+GD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/loadProject.js

@@ -1,7 +1,7 @@
 import { resolveModules } from "./resolve-modules/index.js";
 import { TypeCompiler, ValueErrorType } from "@sinclair/typebox/compiler";
 import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
-import { createRoot, createSignal, createEffect } from "./reactivity/solid.js";
+import { createRoot, createSignal, createEffect, batch } from "./reactivity/solid.js";
 import { createMessagesQuery } from "./createMessagesQuery.js";
 import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.js";
 import { ProjectSettings } from "./versionedInterfaces.js";
@@ -72,7 +72,11 @@ export async function loadProject(args) {
                         pathPattern: projectPath + "/messages.json",
                     };
                 }
-                _setSettings(validatedSettings);
+                batch(() => {
+                    // reset the resolved modules first - since they are no longer valid at that point
+                    setResolvedModules(undefined);
+                    _setSettings(validatedSettings);
+                });
                 writeSettingsToDisk(validatedSettings);
                 return { data: undefined };
             }

package/dist/loadProject.test.js

@@ -515,8 +515,8 @@ describe("functionality", () => {
                 _import,
             });
             await new Promise((resolve) => setTimeout(resolve, 510));
-            expect(await project.query.messageLintReports.getAll()).toHaveLength(1);
-            expect((await project.query.messageLintReports.getAll())?.[0]?.ruleId).toBe(_mockLintRule.id);
+            expect(await project.query.messageLintReports.getAll.settled()).toHaveLength(1);
+            expect((await project.query.messageLintReports.getAll.settled())?.[0]?.ruleId).toBe(_mockLintRule.id);
             expect(project.installed.messageLintRules()).toHaveLength(1);
         });
         it("should return lint reports for a single message", async () => {
@@ -840,26 +840,6 @@ describe("functionality", () => {
         });
     });
     describe("lint", () => {
-        it.todo("should throw if lint reports are not initialized yet", async () => {
-            const repo = await mockRepo();
-            const fs = repo.nodeishFs;
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
-            const project = await loadProject({
-                projectPath: "/user/project/project.inlang.json",
-                repo,
-                _import,
-            });
-            // TODO: test with real lint rules
-            try {
-                const r = await project.query.messageLintReports.getAll();
-                expect(r).toEqual(undefined);
-                throw new Error("Should not reach this");
-            }
-            catch (e) {
-                expect(e.message).toBe("lint not initialized yet");
-            }
-        });
         it("should return the message lint reports", async () => {
             const settings = {
                 sourceLanguageTag: "en",
@@ -878,7 +858,7 @@ describe("functionality", () => {
                 }),
             });
             // TODO: test with real lint rules
-            const r = await project.query.messageLintReports.getAll();
+            const r = await project.query.messageLintReports.getAll.settled();
             expect(r).toEqual([]);
         });
     });
@@ -907,6 +887,22 @@ describe("functionality", () => {
                     },
                 ],
             };
+            const newMessage = {
+                id: "test2",
+                selectors: [],
+                variants: [
+                    {
+                        match: [],
+                        languageTag: "en",
+                        pattern: [
+                            {
+                                type: "Text",
+                                value: "test",
+                            },
+                        ],
+                    },
+                ],
+            };
             await fs.writeFile("./messages.json", JSON.stringify(messages));
             const getMessages = async (customFs) => {
                 const file = await customFs.readFile("./messages.json", { encoding: "utf-8" });
@@ -938,8 +934,10 @@ describe("functionality", () => {
                 }),
             });
             let counter = 0;
-            project.query.messages.getAll.subscribe(() => {
+            let messageCount = 0;
+            project.query.messages.getAll.subscribe((messages) => {
                 counter = counter + 1;
+                messageCount = messages.length;
             });
             // subscribe fires once
             expect(counter).toBe(1);
@@ -948,16 +946,31 @@ describe("functionality", () => {
             await new Promise((resolve) => setTimeout(resolve, 200)); // file event will lock a file and be handled sequentially - give it time to pickup the change
             // we didn't change the message we write into message.json - shouldn't change the messages
             expect(counter).toBe(1);
+            expect(messageCount).toBe(1);
             // saving the file without changing should trigger a change
             messages.data[0].variants[0].pattern[0].value = "changed";
             await fs.writeFile("./messages.json", JSON.stringify(messages));
             await new Promise((resolve) => setTimeout(resolve, 200)); // file event will lock a file and be handled sequentially - give it time to pickup the change
             expect(counter).toBe(2);
+            expect(messageCount).toBe(1);
             messages.data[0].variants[0].pattern[0].value = "changed3";
-            // change file
+            // change file - update message
             await fs.writeFile("./messages.json", JSON.stringify(messages));
             await new Promise((resolve) => setTimeout(resolve, 200)); // file event will lock a file and be handled sequentially - give it time to pickup the change
             expect(counter).toBe(3);
+            expect(messageCount).toBe(1);
+            // change file - add a message
+            messages.data.push(newMessage);
+            await fs.writeFile("./messages.json", JSON.stringify(messages));
+            await new Promise((resolve) => setTimeout(resolve, 200)); // file event will lock a file and be handled sequentially - give it time to pickup the change
+            expect(counter).toBe(4);
+            expect(messageCount).toBe(2);
+            // change file - remove a message
+            messages.data.pop();
+            await fs.writeFile("./messages.json", JSON.stringify(messages));
+            await new Promise((resolve) => setTimeout(resolve, 200)); // file event will lock a file and be handled sequentially - give it time to pickup the change
+            expect(counter).toBe(5);
+            expect(messageCount).toBe(1);
         });
     });
 });

package/dist/reactivity/solid.d.ts

@@ -9,5 +9,6 @@ declare const from: typeof import("solid-js").from;
 declare const batch: typeof import("solid-js").batch;
 declare const getListener: typeof import("solid-js").getListener;
 declare const onCleanup: typeof import("solid-js").onCleanup;
-export { createSignal, createMemo, createRoot, createEffect, createResource, observable, from, batch, getListener, onCleanup, DEV, };
+declare const untrack: typeof import("solid-js").untrack;
+export { createSignal, createMemo, createRoot, createEffect, createResource, observable, from, batch, getListener, onCleanup, untrack, DEV, };
 //# sourceMappingURL=solid.d.ts.map

package/dist/reactivity/solid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solid.d.ts","sourceRoot":"","sources":["../../src/reactivity/solid.ts"],"names":[],"mappings":"AAAA,OAAO,EAWN,GAAG,EAEH,MAAM,wBAAwB,CAAA;AAE/B,QAAA,MAAM,YAAY,wCAA6D,CAAA;AAC/E,QAAA,MAAM,UAAU,sCAAyD,CAAA;AACzE,QAAA,MAAM,UAAU,sCAAyD,CAAA;AACzE,QAAA,MAAM,YAAY,wCAA6D,CAAA;AAC/E,QAAA,MAAM,cAAc,0CAAiE,CAAA;AACrF,QAAA,MAAM,UAAU,sCAAyD,CAAA;AACzE,QAAA,MAAM,IAAI,gCAA6C,CAAA;AACvD,QAAA,MAAM,KAAK,iCAA+C,CAAA;AAC1D,QAAA,MAAM,WAAW,uCAA2D,CAAA;AAC5E,QAAA,MAAM,SAAS,qCAAuD,CAAA;AAEtE,OAAO,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,YAAY,EACZ,cAAc,EACd,UAAU,EACV,IAAI,EACJ,KAAK,EACL,WAAW,EACX,SAAS,EACT,GAAG,GACH,CAAA"}
+{"version":3,"file":"solid.d.ts","sourceRoot":"","sources":["../../src/reactivity/solid.ts"],"names":[],"mappings":"AAAA,OAAO,EAYN,GAAG,EAEH,MAAM,wBAAwB,CAAA;AAE/B,QAAA,MAAM,YAAY,wCAA6D,CAAA;AAC/E,QAAA,MAAM,UAAU,sCAAyD,CAAA;AACzE,QAAA,MAAM,UAAU,sCAAyD,CAAA;AACzE,QAAA,MAAM,YAAY,wCAA6D,CAAA;AAC/E,QAAA,MAAM,cAAc,0CAAiE,CAAA;AACrF,QAAA,MAAM,UAAU,sCAAyD,CAAA;AACzE,QAAA,MAAM,IAAI,gCAA6C,CAAA;AACvD,QAAA,MAAM,KAAK,iCAA+C,CAAA;AAC1D,QAAA,MAAM,WAAW,uCAA2D,CAAA;AAC5E,QAAA,MAAM,SAAS,qCAAuD,CAAA;AACtE,QAAA,MAAM,OAAO,mCAAmD,CAAA;AAEhE,OAAO,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,YAAY,EACZ,cAAc,EACd,UAAU,EACV,IAAI,EACJ,KAAK,EACL,WAAW,EACX,SAAS,EACT,OAAO,EACP,GAAG,GACH,CAAA"}

package/dist/reactivity/solid.js

@@ -1,4 +1,4 @@
-import { createSignal as _createSignal, createMemo as _createMemo, createRoot as _createRoot, createEffect as _createEffect, createResource as _createResource, observable as _observable, batch as _batch, from as _from, getListener as _getListener, onCleanup as _onCleanup, DEV,
+import { createSignal as _createSignal, createMemo as _createMemo, createRoot as _createRoot, createEffect as _createEffect, createResource as _createResource, untrack as _untrack, observable as _observable, batch as _batch, from as _from, getListener as _getListener, onCleanup as _onCleanup, DEV,
 // @ts-ignore
  } from "solid-js/dist/solid.js";
 const createSignal = _createSignal;
@@ -11,4 +11,5 @@ const from = _from;
 const batch = _batch;
 const getListener = _getListener;
 const onCleanup = _onCleanup;
-export { createSignal, createMemo, createRoot, createEffect, createResource, observable, from, batch, getListener, onCleanup, DEV, };
+const untrack = _untrack;
+export { createSignal, createMemo, createRoot, createEffect, createResource, observable, from, batch, getListener, onCleanup, untrack, DEV, };

package/dist/reactivity/solid.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect } from "vitest";
-import { createRoot, createSignal, createEffect, createMemo, createResource } from "./solid.js";
+import { createRoot, createSignal, createEffect, createMemo, createResource, untrack, } from "./solid.js";
+import { ReactiveMap } from "./map.js";
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -155,3 +156,39 @@ describe("solid", () => {
         expect(memo()).toBe("memo = 2000");
     });
 });
+describe("solid", () => {
+    it("solid reactive map allows to use untrack", () => {
+        // @ts-expect-error -- ReactiveMap seem to have problems type arguments here
+        const reactiveMap = new ReactiveMap();
+        const [plainSignal, setPlainSignal] = createSignal(0);
+        let shouldTriggerOnBoth = -1;
+        createEffect(() => {
+            shouldTriggerOnBoth++;
+            reactiveMap.values();
+            plainSignal();
+        });
+        let shouldTriggerOnReactiveMapOnly = -1;
+        createEffect(() => {
+            shouldTriggerOnReactiveMapOnly++;
+            reactiveMap.values();
+            untrack(() => plainSignal());
+        });
+        let shouldTriggerOnPlainSignalOnly = -1;
+        createEffect(() => {
+            shouldTriggerOnPlainSignalOnly++;
+            untrack(() => reactiveMap.values());
+            plainSignal();
+        });
+        expect(shouldTriggerOnBoth).toBe(0);
+        expect(shouldTriggerOnReactiveMapOnly).toBe(0);
+        expect(shouldTriggerOnPlainSignalOnly).toBe(0);
+        setPlainSignal(1);
+        expect(shouldTriggerOnBoth).toBe(1);
+        expect(shouldTriggerOnReactiveMapOnly).toBe(0);
+        expect(shouldTriggerOnPlainSignalOnly).toBe(1);
+        reactiveMap.set("a", "a");
+        expect(shouldTriggerOnBoth).toBe(2);
+        expect(shouldTriggerOnReactiveMapOnly).toBe(1);
+        expect(shouldTriggerOnPlainSignalOnly).toBe(1);
+    });
+});

package/dist/v2/createMessageBundle.d.ts

@@ -0,0 +1,25 @@
+import { LanguageTag, MessageBundle, Message } from "./types.js";
+/**
+ * create v2 MessageBundle
+ * @example createMessageBundle({
+ * 	 id: "greeting",
+ *   messages: [
+ * 		 createMessage({locale: "en", text: "Hello world!"})
+ * 		 createMessage({locale: "de", text: "Hallo Welt!"})
+ *   ]
+ * })
+ */
+export declare function createMessageBundle(args: {
+    id: string;
+    messages: Message[];
+    alias?: MessageBundle["alias"];
+}): MessageBundle;
+/**
+ * create v2 Messsage AST with text-only pattern
+ * @example createMessage({locale: "en", text: "Hello world"})
+ */
+export declare function createMessage(args: {
+    locale: LanguageTag;
+    text: string;
+}): Message;
+//# sourceMappingURL=createMessageBundle.d.ts.map

package/dist/v2/createMessageBundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMessageBundle.d.ts","sourceRoot":"","sources":["../../src/v2/createMessageBundle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,EAAQ,MAAM,YAAY,CAAA;AAEtE;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACzC,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;CAC9B,GAAG,aAAa,CAMhB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAOlF"}

package/dist/v2/createMessageBundle.js

@@ -0,0 +1,36 @@
+import { LanguageTag, MessageBundle, Message, Text } from "./types.js";
+/**
+ * create v2 MessageBundle
+ * @example createMessageBundle({
+ * 	 id: "greeting",
+ *   messages: [
+ * 		 createMessage({locale: "en", text: "Hello world!"})
+ * 		 createMessage({locale: "de", text: "Hallo Welt!"})
+ *   ]
+ * })
+ */
+export function createMessageBundle(args) {
+    return {
+        id: args.id,
+        alias: args.alias ?? {},
+        messages: args.messages,
+    };
+}
+/**
+ * create v2 Messsage AST with text-only pattern
+ * @example createMessage({locale: "en", text: "Hello world"})
+ */
+export function createMessage(args) {
+    return {
+        locale: args.locale,
+        declarations: [],
+        selectors: [],
+        variants: [{ match: [], pattern: [toTextElement(args.text ?? "")] }],
+    };
+}
+function toTextElement(text) {
+    return {
+        type: "text",
+        value: text,
+    };
+}

package/dist/v2/createMessageBundle.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createMessageBundle.test.d.ts.map

package/dist/v2/createMessageBundle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMessageBundle.test.d.ts","sourceRoot":"","sources":["../../src/v2/createMessageBundle.test.ts"],"names":[],"mappings":""}

package/dist/v2/createMessageBundle.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect } from "vitest";
+import { createMessageBundle, createMessage } from "./createMessageBundle.js";
+import { MessageBundle } from "./types.js";
+import { Value } from "@sinclair/typebox/value";
+describe("createMessageBundle", () => {
+    it("creates a bundle with no messages", () => {
+        const bundle = createMessageBundle({ id: "no_messages", messages: [] });
+        expect(Value.Check(MessageBundle, bundle)).toBe(true);
+        expect(bundle).toEqual({
+            id: "no_messages",
+            alias: {},
+            messages: [],
+        });
+    });
+    it("creates a bundle with a single text-only message", () => {
+        const bundle = createMessageBundle({
+            id: "hello_world",
+            messages: [createMessage({ locale: "en", text: "Hello World!" })],
+        });
+        expect(Value.Check(MessageBundle, bundle)).toBe(true);
+        expect(bundle).toEqual({
+            id: "hello_world",
+            alias: {},
+            messages: [
+                {
+                    locale: "en",
+                    declarations: [],
+                    selectors: [],
+                    variants: [
+                        {
+                            match: [],
+                            pattern: [
+                                {
+                                    type: "text",
+                                    value: "Hello World!",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+    it("creates a bundle with multiple text-only messages", () => {
+        const bundle = createMessageBundle({
+            id: "hello_world_2",
+            messages: [
+                createMessage({ locale: "en", text: "Hello World!" }),
+                createMessage({ locale: "de", text: "Hallo Welt!" }),
+            ],
+        });
+        expect(Value.Check(MessageBundle, bundle)).toBe(true);
+        expect(bundle).toEqual({
+            id: "hello_world_2",
+            alias: {},
+            messages: [
+                {
+                    locale: "en",
+                    declarations: [],
+                    selectors: [],
+                    variants: [
+                        {
+                            match: [],
+                            pattern: [
+                                {
+                                    type: "text",
+                                    value: "Hello World!",
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    locale: "de",
+                    declarations: [],
+                    selectors: [],
+                    variants: [
+                        {
+                            match: [],
+                            pattern: [
+                                {
+                                    type: "text",
+                                    value: "Hallo Welt!",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+});

package/dist/v2/mocks/plural/bundle.d.ts

@@ -0,0 +1,3 @@
+import type { MessageBundle } from "../../types.js";
+export declare const bundle: MessageBundle;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/v2/mocks/plural/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../../src/v2/mocks/plural/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,eAAO,MAAM,MAAM,EAAE,aA2IpB,CAAA"}

package/dist/v2/mocks/plural/bundle.js

@@ -0,0 +1,140 @@
+export const bundle = {
+    id: "mock_bundle_human_id",
+    alias: {
+        default: "mock_bundle_alias",
+    },
+    messages: [
+        {
+            locale: "de",
+            declarations: [
+                {
+                    type: "input",
+                    name: "numProducts",
+                    value: {
+                        type: "expression",
+                        arg: {
+                            type: "variable",
+                            name: "numProducts",
+                        },
+                    },
+                },
+            ],
+            selectors: [
+                {
+                    type: "expression",
+                    arg: {
+                        type: "variable",
+                        name: "numProducts",
+                    },
+                    annotation: {
+                        type: "function",
+                        name: "plural",
+                        options: [],
+                    },
+                },
+            ],
+            variants: [
+                {
+                    match: ["zero"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Keine Produkte",
+                        },
+                    ],
+                },
+                {
+                    match: ["one"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Ein Produkt",
+                        },
+                    ],
+                },
+                {
+                    match: ["other"],
+                    pattern: [
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "numProducts",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " Produkte",
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            locale: "en",
+            declarations: [
+                {
+                    type: "input",
+                    name: "numProducts",
+                    value: {
+                        type: "expression",
+                        arg: {
+                            type: "variable",
+                            name: "numProducts",
+                        },
+                    },
+                },
+            ],
+            selectors: [
+                {
+                    type: "expression",
+                    arg: {
+                        type: "variable",
+                        name: "numProducts",
+                    },
+                    annotation: {
+                        type: "function",
+                        name: "plural",
+                        options: [],
+                    },
+                },
+            ],
+            variants: [
+                {
+                    match: ["zero"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "No Products",
+                        },
+                    ],
+                },
+                {
+                    match: ["one"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "A product",
+                        },
+                    ],
+                },
+                {
+                    match: ["other"],
+                    pattern: [
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "numProducts",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " products",
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+};

package/dist/v2/mocks/plural/bundle.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bundle.test.d.ts.map

package/dist/v2/mocks/plural/bundle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.test.d.ts","sourceRoot":"","sources":["../../../../src/v2/mocks/plural/bundle.test.ts"],"names":[],"mappings":""}

package/dist/v2/mocks/plural/bundle.test.js

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { describe, it, expect } from "vitest";
+import { bundle } from "./bundle.js";
+import { MessageBundle } from "../../types.js";
+import { Value } from "@sinclair/typebox/value";
+describe("mock plural messageBundle", () => {
+    it("is valid", () => {
+        const messageBundle = bundle;
+        expect(Value.Check(MessageBundle, messageBundle)).toBe(true);
+        expect(bundle.messages.length).toBe(2);
+        expect(bundle.messages[0].declarations.length).toBe(1);
+        expect(bundle.messages[0].selectors.length).toBe(1);
+        expect(bundle.messages[0].variants.length).toBe(3);
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.34.9",
+  "version": "0.35.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -35,15 +35,15 @@
     "throttle-debounce": "^5.0.0",
     "@inlang/json-types": "1.1.0",
     "@inlang/language-tag": "1.5.1",
-    "@inlang/message": "2.1.0",
-    "@inlang/message-lint-rule": "1.4.7",
-    "@inlang/module": "1.2.11",
     "@inlang/plugin": "2.4.11",
+    "@inlang/message": "2.1.0",
     "@inlang/project-settings": "2.4.2",
+    "@inlang/message-lint-rule": "1.4.7",
     "@inlang/result": "1.1.0",
-    "@inlang/translatable": "1.3.1",
+    "@inlang/module": "1.2.11",
     "@lix-js/client": "1.4.0",
-    "@lix-js/fs": "1.0.0"
+    "@lix-js/fs": "1.0.0",
+    "@inlang/translatable": "1.3.1"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",