@inlang/sdk 0.35.5 → 0.35.7

package/dist/persistence/store.test.js

@@ -0,0 +1,79 @@
+import { test, expect } from "vitest";
+import { createNodeishMemoryFs } from "../test-utilities/index.js";
+import { createMessageBundle, createMessage, injectJSONNewlines, addSlots } from "../v2/helper.js";
+import { openStore, readJSON, writeJSON } from "./store.js";
+const locales = ["en", "de"];
+const mockMessages = [
+    createMessageBundle({
+        id: "first_message",
+        messages: [
+            createMessage({
+                locale: "en",
+                text: "If this fails I will be sad",
+            }),
+        ],
+    }),
+    createMessageBundle({
+        id: "second_message",
+        messages: [
+            createMessage({ locale: "en", text: "Let's see if this works" }),
+            createMessage({ locale: "de", text: "Mal sehen ob das funktioniert" }),
+        ],
+    }),
+];
+test("roundtrip readJSON/writeJSON", async () => {
+    const nodeishFs = createNodeishMemoryFs();
+    const projectPath = "/test/project.inlang";
+    const filePath = projectPath + "/messages.json";
+    const persistedMessages = injectJSONNewlines(JSON.stringify(mockMessages.map((bundle) => addSlots(bundle, locales))));
+    await nodeishFs.mkdir(projectPath, { recursive: true });
+    await nodeishFs.writeFile(filePath, persistedMessages);
+    const firstMessageLoad = await readJSON({
+        filePath,
+        nodeishFs: nodeishFs,
+    });
+    expect(firstMessageLoad).toStrictEqual(mockMessages);
+    await writeJSON({
+        filePath,
+        nodeishFs,
+        messages: firstMessageLoad,
+        locales,
+    });
+    const afterRoundtrip = await nodeishFs.readFile(filePath, { encoding: "utf-8" });
+    expect(afterRoundtrip).toStrictEqual(persistedMessages);
+    const messagesAfterRoundtrip = await readJSON({
+        filePath,
+        nodeishFs,
+    });
+    expect(messagesAfterRoundtrip).toStrictEqual(firstMessageLoad);
+});
+test("openStore does minimal CRUD on messageBundles", async () => {
+    const nodeishFs = createNodeishMemoryFs();
+    const projectPath = "/test/project.inlang";
+    const filePath = projectPath + "/messages.json";
+    const persistedMessages = JSON.stringify(mockMessages);
+    await nodeishFs.mkdir(projectPath, { recursive: true });
+    await nodeishFs.writeFile(filePath, persistedMessages);
+    const store = await openStore({ projectPath, nodeishFs, locales });
+    const messages = await store.messageBundles.getAll();
+    expect(messages).toStrictEqual(mockMessages);
+    const firstMessageBundle = await store.messageBundles.get({ id: "first_message" });
+    expect(firstMessageBundle).toStrictEqual(mockMessages[0]);
+    const modifedMessageBundle = structuredClone(firstMessageBundle);
+    const newMessage = createMessage({ locale: "de", text: "Wenn dies schiefläuft, bin ich sauer" });
+    modifedMessageBundle.messages.push(newMessage);
+    await store.messageBundles.set({ data: modifedMessageBundle });
+    const setMessageBundle = await store.messageBundles.get({ id: "first_message" });
+    expect(setMessageBundle).toStrictEqual(modifedMessageBundle);
+    // no need to sleep here
+    // with batchedIO, the set should await until the write is done
+    const messagesAfterRoundtrip = await readJSON({
+        filePath,
+        nodeishFs,
+    });
+    const expected = [setMessageBundle, ...mockMessages.slice(1)];
+    expect(messagesAfterRoundtrip).toStrictEqual(expected);
+    await store.messageBundles.delete({ id: "first_message" });
+    const messagesAfterDelete = await store.messageBundles.getAll();
+    expect(messagesAfterDelete).toStrictEqual(mockMessages.slice(1));
+});

package/dist/persistence/storeApi.d.ts

@@ -0,0 +1,22 @@
+import type * as V2 from "../v2/types.js";
+/**
+ * WIP async V2 store interface
+ * E.g. `await project.store.messageBundles.get({ id: "..." })`
+ **/
+export type StoreApi = {
+    messageBundles: Store<V2.MessageBundle>;
+};
+export interface Store<T> {
+    reload: () => Promise<void>;
+    get: (args: {
+        id: string;
+    }) => Promise<T | undefined>;
+    set: (args: {
+        data: T;
+    }) => Promise<void>;
+    delete: (args: {
+        id: string;
+    }) => Promise<void>;
+    getAll: () => Promise<T[]>;
+}
+//# sourceMappingURL=storeApi.d.ts.map

package/dist/persistence/storeApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storeApi.d.ts","sourceRoot":"","sources":["../../src/persistence/storeApi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAEzC;;;IAGI;AACJ,MAAM,MAAM,QAAQ,GAAG;IACtB,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CAAC,CAAA;CACvC,CAAA;AAED,MAAM,WAAW,KAAK,CAAC,CAAC;IAEvB,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAE3B,GAAG,EAAE,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA;IACrD,GAAG,EAAE,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACzC,MAAM,EAAE,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/C,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,CAAA;CAC1B"}

package/dist/persistence/storeApi.js

@@ -0,0 +1 @@
+export {};

package/dist/reactivity/solid.test.js

@@ -1,12 +1,7 @@
 import { describe, it, expect } from "vitest";
+import { sleep, delay } from "../test-utilities/sleep.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));
-}
-function delay(v, ms) {
-    return new Promise((resolve) => setTimeout(() => resolve(v), ms));
-}
 describe("vitest", () => {
     it("waits for the result of an async function", async () => {
         const rval = await delay(42, 1);

package/dist/resolve-modules/plugins/resolvePlugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolvePlugins.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/resolvePlugins.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAwBxD,eAAO,MAAM,cAAc,EAAE,sBAgH5B,CAAA"}
+{"version":3,"file":"resolvePlugins.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/resolvePlugins.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAoBxD,eAAO,MAAM,cAAc,EAAE,sBA2G5B,CAAA"}

package/dist/resolve-modules/plugins/resolvePlugins.js

@@ -1,5 +1,4 @@
 import { Plugin } from "@inlang/plugin";
-import { loadMessages as sdkLoadMessages, saveMessages as sdkSaveMessages, } from "../../persistence/plugin.js";
 import { PluginReturnedInvalidCustomApiError, PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginsDoNotProvideLoadOrSaveMessagesError, PluginHasInvalidIdError, PluginHasInvalidSchemaError, } from "./errors.js";
 import { deepmerge } from "deepmerge-ts";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
@@ -84,15 +83,9 @@ export const resolvePlugins = async (args) => {
         }
     }
     // --- LOADMESSAGE / SAVEMESSAGE NOT DEFINED ---
-    if (experimentalPersistence) {
-        debug("Override load/save for experimental persistence");
-        // @ts-ignore - type mismatch error
-        result.data.loadMessages = sdkLoadMessages;
-        // @ts-ignore - type mismatch error
-        result.data.saveMessages = sdkSaveMessages;
-    }
-    else if (typeof result.data.loadMessages !== "function" ||
-        typeof result.data.saveMessages !== "function") {
+    if (!experimentalPersistence &&
+        (typeof result.data.loadMessages !== "function" ||
+            typeof result.data.saveMessages !== "function")) {
         result.errors.push(new PluginsDoNotProvideLoadOrSaveMessagesError());
     }
     return result;

package/dist/test-utilities/sleep.d.ts

@@ -0,0 +1,4 @@
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function delay(v: unknown, ms: number): Promise<unknown>;
+export declare function fail(ms: number): Promise<unknown>;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/test-utilities/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../src/test-utilities/sleep.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAE/B;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,oBAE3C;AAED,wBAAgB,IAAI,CAAC,EAAE,EAAE,MAAM,oBAE9B"}

package/dist/test-utilities/sleep.js

@@ -0,0 +1,9 @@
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function delay(v, ms) {
+    return new Promise((resolve) => setTimeout(() => resolve(v), ms));
+}
+export function fail(ms) {
+    return new Promise((resolve, reject) => setTimeout(() => reject(new Error("fail")), ms));
+}

package/dist/v2/helper.d.ts

@@ -0,0 +1,131 @@
+import { LanguageTag, MessageBundle, MessageBundleWithSlots, Message, MessageSlot, 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 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;
+    match?: Array<string>;
+}): Message;
+export declare function toTextElement(text: string): Text;
+/**
+ * create MessageSlot for a locale (only used for persistence)
+ */
+export declare function createMessageSlot(locale: LanguageTag): MessageSlot;
+/**
+ * return structuredClone with message slots for all locales not yet present
+ */
+export declare function addSlots(messageBundle: MessageBundle, locales: string[]): MessageBundleWithSlots;
+/**
+ * remove empty message slots without first creating a structured clone
+ */
+export declare function removeSlots(messageBundle: MessageBundleWithSlots): {
+    id: string;
+    alias: Record<string, string>;
+    messages: {
+        selectors: {
+            annotation?: {
+                type: "function";
+                name: string;
+                options: {
+                    name: string;
+                    value: {
+                        type: "literal";
+                        value: string;
+                    } | {
+                        type: "variable";
+                        name: string;
+                    };
+                }[];
+            } | undefined;
+            type: "expression";
+            arg: {
+                type: "literal";
+                value: string;
+            } | {
+                type: "variable";
+                name: string;
+            };
+        }[];
+        variants: {
+            match: string[];
+            pattern: ({
+                type: "text";
+                value: string;
+            } | {
+                annotation?: {
+                    type: "function";
+                    name: string;
+                    options: {
+                        name: string;
+                        value: {
+                            type: "literal";
+                            value: string;
+                        } | {
+                            type: "variable";
+                            name: string;
+                        };
+                    }[];
+                } | undefined;
+                type: "expression";
+                arg: {
+                    type: "literal";
+                    value: string;
+                } | {
+                    type: "variable";
+                    name: string;
+                };
+            })[];
+        }[];
+        locale: string;
+        declarations: {
+            type: "input";
+            name: string;
+            value: {
+                annotation?: {
+                    type: "function";
+                    name: string;
+                    options: {
+                        name: string;
+                        value: {
+                            type: "literal";
+                            value: string;
+                        } | {
+                            type: "variable";
+                            name: string;
+                        };
+                    }[];
+                } | undefined;
+                type: "expression";
+                arg: {
+                    type: "literal";
+                    value: string;
+                } | {
+                    type: "variable";
+                    name: string;
+                };
+            };
+        }[];
+    }[];
+};
+/**
+ * Add newlines between bundles and messages to avoid merge conflicts
+ */
+export declare function injectJSONNewlines(json: string): string;
+//# sourceMappingURL=helper.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../src/v2/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,WAAW,EACX,aAAa,EACb,sBAAsB,EACtB,OAAO,EACP,WAAW,EACX,IAAI,EACJ,MAAM,YAAY,CAAA;AAEnB;;;;;;;;;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;IACnC,MAAM,EAAE,WAAW,CAAA;IACnB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CACrB,GAAG,OAAO,CAOV;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAKhD;AAMD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAKlE;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,sBAAsB,CAMhG;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,aAAa,EAAE,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGhE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMvD"}

package/dist/v2/helper.js

@@ -0,0 +1,75 @@
+import { LanguageTag, MessageBundle, MessageBundleWithSlots, Message, MessageSlot, 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: args.match ? args.match : [], pattern: [toTextElement(args.text ?? "")] }],
+    };
+}
+export function toTextElement(text) {
+    return {
+        type: "text",
+        value: text,
+    };
+}
+// ****************************
+// WIP experimental persistence
+// ****************************
+/**
+ * create MessageSlot for a locale (only used for persistence)
+ */
+export function createMessageSlot(locale) {
+    return {
+        locale,
+        slot: true,
+    };
+}
+/**
+ * return structuredClone with message slots for all locales not yet present
+ */
+export function addSlots(messageBundle, locales) {
+    const bundle = structuredClone(messageBundle);
+    bundle.messages = locales.map((locale) => {
+        return bundle.messages.find((message) => message.locale === locale) ?? createMessageSlot(locale);
+    });
+    return bundle;
+}
+/**
+ * remove empty message slots without first creating a structured clone
+ */
+export function removeSlots(messageBundle) {
+    messageBundle.messages = messageBundle.messages.filter((message) => !("slot" in message));
+    return messageBundle;
+}
+/**
+ * Add newlines between bundles and messages to avoid merge conflicts
+ */
+export function injectJSONNewlines(json) {
+    return json
+        .replace(/\{"id":"/g, '\n\n\n\n{"id":"')
+        .replace(/"messages":\[\{"locale":"/g, '"messages":[\n\n\n\n{"locale":"')
+        .replace(/\}\]\}\]\},\{"locale":"/g, '}]}]},\n\n\n\n{"locale":"')
+        .replace(/"slot":true\},\{"locale":/g, '"slot":true},\n\n\n\n{"locale":');
+}

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

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

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

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

package/dist/v2/{createMessageBundle.test.js → helper.test.js}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { createMessageBundle, createMessage } from "./createMessageBundle.js";
+import { createMessageBundle, createMessage } from "./helper.js";
 import { MessageBundle } from "./types.js";
 import { Value } from "@sinclair/typebox/value";
 describe("createMessageBundle", () => {

package/dist/v2/index.d.ts

@@ -1,2 +1,4 @@
 export type * from "./types.js";
+export * from "./helper.js";
+export * from "./shim.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,YAAY,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA"}

package/dist/v2/index.js

@@ -1 +1,2 @@
-export {};
+export * from "./helper.js";
+export * from "./shim.js";

package/dist/v2/mocks/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./plural/bundle.js";
+export * from "./multipleMatcher/bundle.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/v2/mocks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/v2/mocks/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,6BAA6B,CAAA"}

package/dist/v2/mocks/index.js

@@ -0,0 +1,2 @@
+export * from "./plural/bundle.js";
+export * from "./multipleMatcher/bundle.js";

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

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

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

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

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

@@ -0,0 +1,194 @@
+export const multipleMatcherBundle = {
+    id: "mock-bundle-human-id",
+    alias: {
+        default: "mock-bundle-alias",
+    },
+    messages: [
+        {
+            locale: "en",
+            declarations: [],
+            selectors: [
+                {
+                    type: "expression",
+                    arg: {
+                        type: "variable",
+                        name: "count",
+                    },
+                    annotation: { type: "function", name: "plural", options: [] },
+                },
+            ],
+            variants: [
+                {
+                    match: ["one"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Show ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " message.",
+                        },
+                    ],
+                },
+                {
+                    match: ["many"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Show ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " messages.",
+                        },
+                    ],
+                },
+                {
+                    match: ["*"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Show ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            locale: "de",
+            declarations: [],
+            selectors: [
+                {
+                    type: "expression",
+                    arg: {
+                        type: "variable",
+                        name: "count",
+                    },
+                    annotation: { type: "function", name: "plural", options: [] },
+                },
+                {
+                    type: "expression",
+                    arg: {
+                        type: "variable",
+                        name: "formal",
+                    },
+                    annotation: { type: "function", name: "bool", options: [] },
+                },
+            ],
+            variants: [
+                {
+                    match: ["one", "formal"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Zeigen Sie bitte Ihre Nachricht.",
+                        },
+                    ],
+                },
+                {
+                    match: ["one", "informal"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Zeigen Deine Nachricht.",
+                        },
+                    ],
+                },
+                {
+                    match: ["many", "formal"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Zeigen Sie bitte Ihre ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " Nachrichten.",
+                        },
+                    ],
+                },
+                {
+                    match: ["many", "informal"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Zeigen Deine ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " Nachrichten.",
+                        },
+                    ],
+                },
+                {
+                    match: ["many", "*"],
+                    pattern: [
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " Nachrichten zeigen.",
+                        },
+                    ],
+                },
+                {
+                    match: ["*"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Zeige ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+};

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { describe, it, expect } from "vitest";
+import { multipleMatcherBundle } from "./bundle.js";
+import { MessageBundle } from "../../types.js";
+import { Value } from "@sinclair/typebox/value";
+describe("mock plural messageBundle", () => {
+    it("is valid", () => {
+        const messageBundle = multipleMatcherBundle;
+        expect(Value.Check(MessageBundle, messageBundle)).toBe(true);
+    });
+});

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

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

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

@@ -1 +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"}
+{"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,YAAY,EAAE,aA2I1B,CAAA"}