@inlang/sdk 0.1.0

package/dist/createMessagesQuery.test.js

@@ -0,0 +1,304 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { describe, it, expect } from "vitest";
+import { createMessagesQuery } from "./createMessagesQuery.js";
+import { createEffect, createRoot, createSignal } from "./reactivity/solid.js";
+import { createMessage } from "./test-utilities/createMessage.js";
+const createChangeListener = async (cb) => createEffect(cb);
+describe("create", () => {
+    it("should create a message", () => {
+        const query = createMessagesQuery(() => []);
+        expect(query.get({ where: { id: "first-message" } })).toBeUndefined();
+        const mockMessage = createMessage("first-message", { en: "Hello World" });
+        const created = query.create({ data: mockMessage });
+        expect(query.get({ where: { id: "first-message" } })).toEqual(mockMessage);
+        expect(created).toBe(true);
+    });
+    it("should return false if message with id already exists", () => {
+        const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })]);
+        expect(query.get({ where: { id: "first-message" } })).toBeDefined();
+        const mockMessage = createMessage("first-message", { en: "Some Text" });
+        query.create({ data: mockMessage });
+        const created = query.create({ data: mockMessage });
+        expect(created).toBe(false);
+    });
+});
+describe("get", () => {
+    it("should return undefined if a message does not exist", () => {
+        const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })]);
+        const message = query.get({ where: { id: "none-existent-message" } });
+        expect(message).toBeUndefined();
+    });
+    it("should return an object, not an array", () => {
+        const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })]);
+        const message = query.get({ where: { id: "first-message" } });
+        expect(message).toBeDefined();
+        expect(Array.isArray(message)).toBe(false);
+    });
+    // todo: improve the readonly type
+    it.skip("mutating the returned value should not affect subsequent return values", () => {
+        const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })]);
+        const message1 = query.get({ where: { id: "first-message" } });
+        message1.variants.find((v) => v.languageTag === "en").pattern[0].value =
+            "Hello World 2";
+        const message2 = query.get({ where: { id: "first-message" } });
+        expect(message1.variants.find((v) => v.languageTag === "en").pattern[0].value).toBe("Hello World 2");
+        expect(message2.variants.find((v) => v.languageTag === "en").pattern[0].value).toBe("Hello World");
+    });
+});
+describe("getAll", () => {
+    it("should return an empty array if no messages exist", () => {
+        const query = createMessagesQuery(() => []);
+        const messages = query.getAll();
+        expect(Object.values(messages)).toEqual([]);
+    });
+    it("should return all message objects", () => {
+        const query = createMessagesQuery(() => []);
+        const mockMessage1 = createMessage("first-message", { en: "Hello World" });
+        const mockMessage2 = createMessage("second-message", { en: "Hello World 2" });
+        query.create({ data: mockMessage1 });
+        query.create({ data: mockMessage2 });
+        const messages = query.getAll();
+        expect(Object.values(messages)).toEqual([mockMessage1, mockMessage2]);
+    });
+    // todo: improve the readonly type
+    it.skip("mutating the returned value should not affect subsequent return values", () => {
+        const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })]);
+        const messages1 = query.getAll();
+        Object.values(messages1)[0].variants.find((v) => v.languageTag === "en")
+            .pattern[0].value = "Hello World 2";
+        expect(Object.values(query.getAll())[0].variants.find((v) => v.languageTag === "en")
+            .pattern[0].value).toBe("Hello World");
+    });
+});
+describe("update", () => {
+    it("should update a message", () => {
+        const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })]);
+        expect(query.get({ where: { id: "first-message" } })).toBeDefined();
+        const mockMessage = createMessage("first-message", { en: "Hello World 2" });
+        const updated = query.update({ where: { id: "first-message" }, data: mockMessage });
+        expect(query.get({ where: { id: "first-message" } })).toEqual(mockMessage);
+        expect(updated).toBe(true);
+    });
+    it("should return false if message with id does not exist exists", () => {
+        const query = createMessagesQuery(() => []);
+        expect(query.get({ where: { id: "first-message" } })).toBeUndefined();
+        const mockMessage = createMessage("first-message", { en: "Hello World" });
+        const updated = query.update({ where: { id: "first-message" }, data: mockMessage });
+        expect(updated).toBe(false);
+    });
+});
+describe("upsert", () => {
+    it("should create a message if not present yet", () => {
+        const query = createMessagesQuery(() => []);
+        expect(query.get({ where: { id: "first-message" } })).toBeUndefined();
+        const mockMessage = createMessage("first-message", { en: "Hello World" });
+        const upserted = query.upsert({ where: { id: "first-message" }, data: mockMessage });
+        expect(query.get({ where: { id: "first-message" } })).toEqual(mockMessage);
+        expect(upserted).toBe(true);
+    });
+    it("should update message if id already exists", () => {
+        const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })]);
+        expect(query.get({ where: { id: "first-message" } })).toBeDefined();
+        const mockMessage = createMessage("first-message", { en: "Hello World 2" });
+        const upserted = query.upsert({ where: { id: "first-message" }, data: mockMessage });
+        expect(query.get({ where: { id: "first-message" } })).toEqual(mockMessage);
+        expect(upserted).toBe(true);
+    });
+});
+describe("delete", () => {
+    it("should delete a message", () => {
+        const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })]);
+        expect(query.get({ where: { id: "first-message" } })).toBeDefined();
+        const deleted = query.delete({ where: { id: "first-message" } });
+        expect(query.get({ where: { id: "first-message" } })).toBeUndefined();
+        expect(deleted).toBe(true);
+    });
+    it("should return false if message with id does not exist", () => {
+        const query = createMessagesQuery(() => []);
+        expect(query.get({ where: { id: "first-message" } })).toBeUndefined();
+        const deleted = query.delete({ where: { id: "first-message" } });
+        expect(deleted).toBe(false);
+    });
+});
+describe("reactivity", () => {
+    describe("get", () => {
+        it("should react to `create`", async () => {
+            await createRoot(async () => {
+                const query = createMessagesQuery(() => []);
+                // eslint-disable-next-line unicorn/no-null
+                let message = null;
+                await createChangeListener(() => (message = query.get({ where: { id: "1" } })));
+                expect(message).toBeUndefined();
+                query.create({ data: createMessage("1", { en: "before" }) });
+                expect(message).toBeDefined();
+                const anotherMessage = query.get({ where: { id: "1" } });
+                expect(anotherMessage).toBeDefined();
+                expect(message).toStrictEqual(anotherMessage);
+            });
+        });
+        it("should react to `update`", async () => {
+            await createRoot(async () => {
+                const query = createMessagesQuery(() => [createMessage("1", { en: "before" })]);
+                let message;
+                await createChangeListener(() => (message = query.get({ where: { id: "1" } })));
+                expect(message).toBeDefined();
+                expect((message?.variants.find((variant) => variant.languageTag === "en")?.pattern[0])
+                    .value).toBe("before");
+                query.update({ where: { id: "1" }, data: createMessage("1", { en: "after" }) });
+                expect((message?.variants.find((variant) => variant.languageTag === "en")?.pattern[0])
+                    .value).toBe("after");
+            });
+        });
+        it("should react to `upsert`", async () => {
+            await createRoot(async () => {
+                const query = createMessagesQuery(() => []);
+                let message;
+                await createChangeListener(() => (message = query.get({ where: { id: "1" } })));
+                expect(message).toBeUndefined();
+                query.upsert({ where: { id: "1" }, data: createMessage("1", { en: "before" }) });
+                expect(message).toBeDefined();
+                expect((message?.variants.find((variant) => variant.languageTag === "en")?.pattern[0])
+                    .value).toBe("before");
+                query.upsert({ where: { id: "1" }, data: createMessage("1", { en: "after" }) });
+                expect((message?.variants.find((variant) => variant.languageTag === "en")?.pattern[0])
+                    .value).toBe("after");
+            });
+        });
+        it("should react to `delete`", async () => {
+            await createRoot(async () => {
+                const query = createMessagesQuery(() => [createMessage("1", { en: "" })]);
+                let message;
+                await createChangeListener(() => (message = query.get({ where: { id: "1" } })));
+                expect(message).toBeDefined();
+                query.delete({ where: { id: "1" } });
+                expect(message).toBeUndefined();
+            });
+        });
+        it("should react to changes to the input `messages`", async () => {
+            const [messages, setMessages] = createSignal([]);
+            const query = createMessagesQuery(messages);
+            // eslint-disable-next-line unicorn/no-null
+            let message = null;
+            await createChangeListener(() => (message = query.get({ where: { id: "1" } })));
+            expect(message).toBeUndefined();
+            query.create({ data: createMessage("1", { en: "before" }) });
+            expect(message).toBeDefined();
+            expect((message.variants.find((variant) => variant.languageTag === "en")?.pattern[0])
+                .value).toBe("before");
+            setMessages([createMessage("1", { en: "after" })]);
+            expect(message).toBeDefined();
+            expect((message.variants.find((variant) => variant.languageTag === "en")?.pattern[0])
+                .value).toBe("after");
+        });
+    });
+    describe.todo("subscribe", () => {
+        // TODO: add tests for `subscribe`
+    });
+    describe("getAll", () => {
+        it("should react to `create`", async () => {
+            await createRoot(async () => {
+                const query = createMessagesQuery(() => []);
+                let messages = undefined;
+                await createChangeListener(() => (messages = query.getAll()));
+                expect(Object.values(messages)).toHaveLength(0);
+                query.create({ data: createMessage("1", { en: "before" }) });
+                expect(Object.values(messages)).toHaveLength(1);
+                query.create({ data: createMessage("2", { en: "before" }) });
+                expect(Object.values(messages)).toHaveLength(2);
+                query.create({ data: createMessage("3", { en: "before" }) });
+                expect(Object.values(messages)).toHaveLength(3);
+            });
+        });
+        it("should react to `update`", async () => {
+            await createRoot(async () => {
+                const query = createMessagesQuery(() => [createMessage("1", { en: "before" })]);
+                let messages = undefined;
+                await createChangeListener(() => (messages = query.getAll()));
+                expect(Object.values(messages)).toHaveLength(1);
+                expect(Object.values(messages)[0].variants.find((variant) => variant.languageTag === "en")
+                    .pattern[0].value).toBe("before");
+                query.update({ where: { id: "1" }, data: createMessage("1", { en: "after" }) });
+                expect(Object.values(messages)).toHaveLength(1);
+                expect(Object.values(messages)[0].variants.find((variant) => variant.languageTag === "en")
+                    .pattern[0].value).toBe("after");
+            });
+        });
+        it("should react to `upsert`", async () => {
+            await createRoot(async () => {
+                const query = createMessagesQuery(() => []);
+                let messages = undefined;
+                await createChangeListener(() => (messages = query.getAll()));
+                expect(Object.values(messages)).toHaveLength(0);
+                query.upsert({ where: { id: "1" }, data: createMessage("1", { en: "before" }) });
+                expect(Object.values(messages)).toHaveLength(1);
+                expect(Object.values(messages)[0].variants.find((variant) => variant.languageTag === "en")
+                    .pattern[0].value).toBe("before");
+                query.upsert({ where: { id: "1" }, data: createMessage("1", { en: "after" }) });
+                expect(Object.values(messages)[0].variants.find((variant) => variant.languageTag === "en")
+                    .pattern[0].value).toBe("after");
+            });
+        });
+        it("should react to `delete`", async () => {
+            await createRoot(async () => {
+                const query = createMessagesQuery(() => [
+                    createMessage("1", { en: "" }),
+                    createMessage("2", { en: "" }),
+                    createMessage("3", { en: "" }),
+                ]);
+                let messages = undefined;
+                await createChangeListener(() => (messages = query.getAll()));
+                expect(Object.values(messages)).toHaveLength(3);
+                query.delete({ where: { id: "1" } });
+                expect(Object.values(messages)).toHaveLength(2);
+                // deleting the same id again should not have an effect
+                query.delete({ where: { id: "1" } });
+                expect(Object.values(messages)).toHaveLength(2);
+                query.delete({ where: { id: "2" } });
+                expect(Object.values(messages)).toHaveLength(1);
+                query.delete({ where: { id: "3" } });
+                expect(Object.values(messages)).toHaveLength(0);
+            });
+        });
+        it("should react to changes to the input `messages`", async () => {
+            const [inputMessages, setMessages] = createSignal([
+                createMessage("1", { en: "before" }),
+            ]);
+            const query = createMessagesQuery(inputMessages);
+            let messages = undefined;
+            await createChangeListener(() => (messages = query.getAll()));
+            expect(Object.values(messages)).toHaveLength(1);
+            query.create({ data: createMessage("2", { en: "" }) });
+            expect(Object.values(messages)).toHaveLength(2);
+            expect(Object.values(messages)[0].variants.find((variant) => variant.languageTag === "en")
+                .pattern[0].value).toBe("before");
+            setMessages([createMessage("1", { en: "after" })]);
+            expect(Object.values(messages)).toHaveLength(1);
+            expect(Object.values(messages)[0].variants.find((variant) => variant.languageTag === "en")
+                .pattern[0].value).toBe("after");
+        });
+    });
+});
+it("instances should not share state", async () => {
+    await createRoot(async () => {
+        const query1 = createMessagesQuery(() => [createMessage("1", { en: "before" })]);
+        const query2 = createMessagesQuery(() => []);
+        // eslint-disable-next-line unicorn/no-null
+        let message1 = null;
+        await createChangeListener(() => (message1 = query1.get({ where: { id: "1" } })));
+        // eslint-disable-next-line unicorn/no-null
+        let message2 = null;
+        await createChangeListener(() => (message2 = query2.get({ where: { id: "1" } })));
+        expect(message1).toBeDefined();
+        expect(message2).toBeUndefined();
+        query2.create({ data: createMessage("1", { en: "before" }) });
+        expect(message2).toBeDefined();
+        query1.update({ where: { id: "1" }, data: createMessage("1", { en: "after" }) });
+        expect(message1.variants.find((variant) => variant.languageTag === "en").pattern[0]
+            .value).toBe("after");
+        expect(message2.variants.find((variant) => variant.languageTag === "en").pattern[0]
+            .value).toBe("before");
+        query1.delete({ where: { id: "1" } });
+        expect(message1).toBeUndefined();
+        expect(message2).toBeDefined();
+    });
+});

package/dist/errors.d.ts

@@ -0,0 +1,22 @@
+export declare class InvalidConfigError extends Error {
+    constructor(message: string, options: ErrorOptions);
+}
+export declare class ProjectFileJSONSyntaxError extends Error {
+    constructor(message: string, options: ErrorOptions);
+}
+export declare class ProjectFilePathNotFoundError extends Error {
+    constructor(message: string, options: ErrorOptions);
+}
+export declare class PluginSaveMessagesError extends Error {
+    constructor(message: string, options: ErrorOptions);
+}
+export declare class PluginLoadMessagesError extends Error {
+    constructor(message: string, options: ErrorOptions);
+}
+/**
+ * Error when no package provides the API to handle messages.
+ */
+export declare class NoPluginProvidesLoadOrSaveMessagesError extends Error {
+    constructor();
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,kBAAmB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;CAIlD;AAED,qBAAa,0BAA2B,SAAQ,KAAK;gBACxC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;CAIlD;AAED,qBAAa,4BAA6B,SAAQ,KAAK;gBAC1C,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;CAIlD;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;CAIlD;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;CAIlD;AAED;;GAEG;AACH,qBAAa,uCAAwC,SAAQ,KAAK;;CAOjE"}

package/dist/errors.js

@@ -0,0 +1,39 @@
+export class InvalidConfigError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "InvalidConfigError";
+    }
+}
+export class ProjectFileJSONSyntaxError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ProjectFileJSONSyntaxError";
+    }
+}
+export class ProjectFilePathNotFoundError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ProjectFilePathNotFoundError";
+    }
+}
+export class PluginSaveMessagesError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "PluginSaveMessagesError";
+    }
+}
+export class PluginLoadMessagesError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "PluginLoadMessagesError";
+    }
+}
+/**
+ * Error when no package provides the API to handle messages.
+ */
+export class NoPluginProvidesLoadOrSaveMessagesError extends Error {
+    constructor() {
+        super("It seems you did not install any plugin that handles messages. Please add one to make inlang work. See https://inlang.com/documentation/plugins/registry."); // TODO: check if link is correct
+        this.name = "NoPluginProvidesLoadOrSaveMessagesError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ *! PUBLIC API FOR THE INLANG SDK.
+ *!
+ *! EXPORT AS LITTLE AS POSSIBLE TO MINIMIZE THE CHANCE OF BREAKING CHANGES.
+ */
+export type { InlangProject, InstalledMessageLintRule, InstalledPlugin, MessageQueryApi, Subscribable, } from "./api.js";
+export { type ImportFunction, createImport } from "./resolve-modules/index.js";
+export { openInlangProject } from "./openInlangProject.js";
+export { solidAdapter, type InlangProjectWithSolidAdapter } from "./adapter/solidAdapter.js";
+export { createMessagesQuery } from "./createMessagesQuery.js";
+export { ProjectFilePathNotFoundError, ProjectFileJSONSyntaxError, InvalidConfigError, NoPluginProvidesLoadOrSaveMessagesError, PluginLoadMessagesError, PluginSaveMessagesError, } from "./errors.js";
+export * from "./messages/variant.js";
+export * from "./versionedInterfaces.js";
+export { InlangModule } from "@inlang/module";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACX,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,YAAY,GACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,EAAE,YAAY,EAAE,KAAK,6BAA6B,EAAE,MAAM,2BAA2B,CAAA;AAC5F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EACN,4BAA4B,EAC5B,0BAA0B,EAC1B,kBAAkB,EAClB,uCAAuC,EACvC,uBAAuB,EACvB,uBAAuB,GACvB,MAAM,aAAa,CAAA;AAEpB,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ *! PUBLIC API FOR THE INLANG SDK.
+ *!
+ *! EXPORT AS LITTLE AS POSSIBLE TO MINIMIZE THE CHANCE OF BREAKING CHANGES.
+ */
+export { createImport } from "./resolve-modules/index.js";
+export { openInlangProject } from "./openInlangProject.js";
+export { solidAdapter } from "./adapter/solidAdapter.js";
+export { createMessagesQuery } from "./createMessagesQuery.js";
+export { ProjectFilePathNotFoundError, ProjectFileJSONSyntaxError, InvalidConfigError, NoPluginProvidesLoadOrSaveMessagesError, PluginLoadMessagesError, PluginSaveMessagesError, } from "./errors.js";
+export * from "./messages/variant.js";
+export * from "./versionedInterfaces.js";
+export { InlangModule } from "@inlang/module";

package/dist/lint/index.d.ts

@@ -0,0 +1,3 @@
+export { lintSingleMessage } from "./message/lintSingleMessage.js";
+export { lintMessages } from "./message/lintMessages.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lint/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA"}

package/dist/lint/index.js

@@ -0,0 +1,2 @@
+export { lintSingleMessage } from "./message/lintSingleMessage.js";
+export { lintMessages } from "./message/lintMessages.js";

package/dist/lint/message/errors.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Error when a lint rule throws during the linting process.
+ */
+export declare class MessagedLintRuleThrowedError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/lint/message/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/lint/message/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,4BAA6B,SAAQ,KAAK;gBAC1C,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAInD"}

package/dist/lint/message/errors.js

@@ -0,0 +1,9 @@
+/**
+ * Error when a lint rule throws during the linting process.
+ */
+export class MessagedLintRuleThrowedError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "MessagedLintRuleThrowedError";
+    }
+}

package/dist/lint/message/lintMessages.d.ts

@@ -0,0 +1,17 @@
+import type { Message } from "@inlang/message";
+import type { MessagedLintRuleThrowedError } from "./errors.js";
+import type { LanguageTag } from "@inlang/language-tag";
+import type { JSONObject } from "@inlang/json-types";
+import type { MessageLintLevel, MessageLintReport, MessageLintRule } from "@inlang/message-lint-rule";
+export declare const lintMessages: (args: {
+    sourceLanguageTag: LanguageTag;
+    languageTags: LanguageTag[];
+    ruleSettings: Record<MessageLintRule["meta"]["id"], JSONObject>;
+    ruleLevels: Record<MessageLintRule["meta"]["id"], MessageLintLevel>;
+    rules: MessageLintRule[];
+    messages: Message[];
+}) => Promise<{
+    data: MessageLintReport[];
+    errors: MessagedLintRuleThrowedError[];
+}>;
+//# sourceMappingURL=lintMessages.d.ts.map

package/dist/lint/message/lintMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lintMessages.d.ts","sourceRoot":"","sources":["../../../src/lint/message/lintMessages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAE9C,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,KAAK,EACX,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,MAAM,2BAA2B,CAAA;AAElC,eAAO,MAAM,YAAY,SAAgB;IACxC,iBAAiB,EAAE,WAAW,CAAA;IAC9B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,YAAY,EAAE,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,CAAA;IAC/D,UAAU,EAAE,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC,CAAA;IACnE,KAAK,EAAE,eAAe,EAAE,CAAA;IACxB,QAAQ,EAAE,OAAO,EAAE,CAAA;CACnB,KAAG,QAAQ;IAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC;IAAC,MAAM,EAAE,4BAA4B,EAAE,CAAA;CAAE,CAchF,CAAA"}

package/dist/lint/message/lintMessages.js

@@ -0,0 +1,12 @@
+import { lintSingleMessage } from "./lintSingleMessage.js";
+export const lintMessages = async (args) => {
+    const promises = args.messages.map((message) => lintSingleMessage({
+        ...args,
+        message,
+    }));
+    const results = await Promise.all(promises);
+    return {
+        data: results.flatMap((result) => result.data).filter(Boolean),
+        errors: results.flatMap((result) => result.errors).filter(Boolean),
+    };
+};

package/dist/lint/message/lintMessages.test.d.ts

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

package/dist/lint/message/lintMessages.test.d.ts.map

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

package/dist/lint/message/lintMessages.test.js

@@ -0,0 +1,105 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { lintMessages } from "./lintMessages.js";
+const lintRule1 = {
+    meta: {
+        id: "messageLintRule.x.1",
+        displayName: { en: "" },
+        description: { en: "" },
+    },
+    message: vi.fn(),
+};
+const lintRule2 = {
+    meta: {
+        id: "messageLintRule.x.2",
+        displayName: { en: "" },
+        description: { en: "" },
+    },
+    message: vi.fn(),
+};
+const message1 = { id: "m1" };
+const message2 = { id: "m2" };
+const message3 = { id: "m3" };
+const messages = [message1, message2, message3];
+describe("lintMessages", async () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    test("it should await all messages", async () => {
+        let called = 0;
+        lintRule2.message.mockImplementation(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            called++;
+        });
+        await lintMessages({
+            ruleLevels: {
+                [lintRule1.meta.id]: "warning",
+                [lintRule2.meta.id]: "warning",
+            },
+            ruleSettings: {},
+            sourceLanguageTag: "en",
+            languageTags: [],
+            messages,
+            rules: [lintRule1, lintRule2],
+        });
+        expect(lintRule1.message).toHaveBeenCalledTimes(3);
+        expect(called).toBe(3);
+    });
+    test("it should process all messages and rules in parallel", async () => {
+        const fn = vi.fn();
+        lintRule1.message.mockImplementation(async ({ message }) => {
+            fn("r1", "before", message.id);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            fn("r1", "after", message.id);
+        });
+        lintRule2.message.mockImplementation(async ({ message }) => {
+            fn("r2", "before", message.id);
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            fn("r2", "after", message.id);
+        });
+        await lintMessages({
+            ruleLevels: {
+                [lintRule1.meta.id]: "warning",
+                [lintRule2.meta.id]: "warning",
+            },
+            ruleSettings: {},
+            rules: [lintRule1, lintRule2],
+            sourceLanguageTag: "en",
+            languageTags: [],
+            messages,
+        });
+        expect(fn).toHaveBeenCalledTimes(12);
+        expect(fn).toHaveBeenNthCalledWith(1, "r1", "before", "m1");
+        expect(fn).toHaveBeenNthCalledWith(2, "r2", "before", "m1");
+        expect(fn).toHaveBeenNthCalledWith(3, "r1", "before", "m2");
+        expect(fn).toHaveBeenNthCalledWith(4, "r2", "before", "m2");
+        expect(fn).toHaveBeenNthCalledWith(5, "r1", "before", "m3");
+        expect(fn).toHaveBeenNthCalledWith(6, "r2", "before", "m3");
+        expect(fn).toHaveBeenNthCalledWith(7, "r1", "after", "m1");
+        expect(fn).toHaveBeenNthCalledWith(8, "r2", "after", "m1");
+        expect(fn).toHaveBeenNthCalledWith(9, "r1", "after", "m2");
+        expect(fn).toHaveBeenNthCalledWith(10, "r2", "after", "m2");
+        expect(fn).toHaveBeenNthCalledWith(11, "r1", "after", "m3");
+        expect(fn).toHaveBeenNthCalledWith(12, "r2", "after", "m3");
+    });
+    test("it should not abort the linting process when errors occur", async () => {
+        lintRule1.message.mockImplementation(({ report }) => {
+            report({});
+        });
+        lintRule2.message.mockImplementation(() => {
+            throw new Error("error");
+        });
+        const { data, errors } = await lintMessages({
+            ruleLevels: {
+                [lintRule1.meta.id]: "warning",
+                [lintRule2.meta.id]: "warning",
+            },
+            ruleSettings: {},
+            sourceLanguageTag: "en",
+            languageTags: [],
+            messages,
+            rules: [lintRule1, lintRule2],
+        });
+        expect(data).toHaveLength(3);
+        expect(errors).toHaveLength(3);
+    });
+});

package/dist/lint/message/lintSingleMessage.d.ts

@@ -0,0 +1,23 @@
+import type { MessageLintLevel, MessageLintRule, MessageLintReport } from "@inlang/message-lint-rule";
+import type { Message } from "@inlang/message";
+import { MessagedLintRuleThrowedError } from "./errors.js";
+import type { LanguageTag } from "@inlang/language-tag";
+import type { JSONObject } from "@inlang/json-types";
+/**
+ * Lint a single message.
+ *
+ * - the lint rule levels defaults to `warning`.
+ */
+export declare const lintSingleMessage: (args: {
+    sourceLanguageTag: LanguageTag;
+    languageTags: LanguageTag[];
+    ruleSettings: Record<MessageLintRule["meta"]["id"], JSONObject>;
+    ruleLevels: Record<MessageLintRule["meta"]["id"], MessageLintLevel>;
+    rules: MessageLintRule[];
+    messages: Message[];
+    message: Message;
+}) => Promise<{
+    data: MessageLintReport[];
+    errors: MessagedLintRuleThrowedError[];
+}>;
+//# sourceMappingURL=lintSingleMessage.d.ts.map

package/dist/lint/message/lintSingleMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lintSingleMessage.d.ts","sourceRoot":"","sources":["../../../src/lint/message/lintSingleMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,SAAgB;IAC7C,iBAAiB,EAAE,WAAW,CAAA;IAC9B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,YAAY,EAAE,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,CAAA;IAC/D,UAAU,EAAE,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,gBAAgB,CAAC,CAAA;IACnE,KAAK,EAAE,eAAe,EAAE,CAAA;IACxB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;CAChB;UAAmB,iBAAiB,EAAE;YAAU,4BAA4B,EAAE;EAsC9E,CAAA"}