@inlang/sdk 0.3.0 → 0.5.0

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

@@ -1,20 +1,16 @@
 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(),
+    id: "messageLintRule.x.1",
+    displayName: { en: "" },
+    description: { en: "" },
+    run: vi.fn(),
 };
 const lintRule2 = {
-    meta: {
-        id: "messageLintRule.x.2",
-        displayName: { en: "" },
-        description: { en: "" },
-    },
-    message: vi.fn(),
+    id: "messageLintRule.x.2",
+    displayName: { en: "" },
+    description: { en: "" },
+    run: vi.fn(),
 };
 const message1 = { id: "m1" };
 const message2 = { id: "m2" };
@@ -26,45 +22,49 @@ describe("lintMessages", async () => {
     });
     test("it should await all messages", async () => {
         let called = 0;
-        lintRule2.message.mockImplementation(async () => {
+        lintRule2.run.mockImplementation(async () => {
             await new Promise((resolve) => setTimeout(resolve, 0));
             called++;
         });
         await lintMessages({
-            ruleLevels: {
-                [lintRule1.meta.id]: "warning",
-                [lintRule2.meta.id]: "warning",
+            settings: {
+                sourceLanguageTag: "en",
+                languageTags: [],
+                modules: [],
+                messageLintRuleLevels: {
+                    [lintRule1.id]: "warning",
+                    [lintRule2.id]: "warning",
+                },
             },
-            ruleSettings: {},
-            sourceLanguageTag: "en",
-            languageTags: [],
             messages,
             rules: [lintRule1, lintRule2],
         });
-        expect(lintRule1.message).toHaveBeenCalledTimes(3);
+        expect(lintRule1.run).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 }) => {
+        lintRule1.run.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 }) => {
+        lintRule2.run.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",
+            settings: {
+                sourceLanguageTag: "en",
+                languageTags: [],
+                modules: [],
+                messageLintRuleLevels: {
+                    [lintRule1.id]: "warning",
+                    [lintRule2.id]: "warning",
+                },
             },
-            ruleSettings: {},
             rules: [lintRule1, lintRule2],
-            sourceLanguageTag: "en",
-            languageTags: [],
             messages,
         });
         expect(fn).toHaveBeenCalledTimes(12);
@@ -82,20 +82,22 @@ describe("lintMessages", async () => {
         expect(fn).toHaveBeenNthCalledWith(12, "r2", "after", "m3");
     });
     test("it should not abort the linting process when errors occur", async () => {
-        lintRule1.message.mockImplementation(({ report }) => {
+        lintRule1.run.mockImplementation(({ report }) => {
             report({});
         });
-        lintRule2.message.mockImplementation(() => {
+        lintRule2.run.mockImplementation(() => {
             throw new Error("error");
         });
         const { data, errors } = await lintMessages({
-            ruleLevels: {
-                [lintRule1.meta.id]: "warning",
-                [lintRule2.meta.id]: "warning",
+            settings: {
+                sourceLanguageTag: "en",
+                languageTags: [],
+                modules: [],
+                messageLintRuleLevels: {
+                    [lintRule1.id]: "warning",
+                    [lintRule2.id]: "warning",
+                },
             },
-            ruleSettings: {},
-            sourceLanguageTag: "en",
-            languageTags: [],
             messages,
             rules: [lintRule1, lintRule2],
         });

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

@@ -1,18 +1,14 @@
-import type { MessageLintLevel, MessageLintRule, MessageLintReport } from "@inlang/message-lint-rule";
+import type { 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";
+import type { ProjectSettings } from "@inlang/project-settings";
 /**
  * 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>;
+    settings: ProjectSettings & Required<Pick<ProjectSettings, "messageLintRuleLevels">>;
     rules: MessageLintRule[];
     messages: Message[];
     message: Message;

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

@@ -1 +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"}
+{"version":3,"file":"lintSingleMessage.d.ts","sourceRoot":"","sources":["../../../src/lint/message/lintSingleMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AACnF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,SAAgB;IAC7C,QAAQ,EAAE,eAAe,GAAG,SAAS,KAAK,eAAe,EAAE,uBAAuB,CAAC,CAAC,CAAA;IACpF,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"}

package/dist/lint/message/lintSingleMessage.js

@@ -8,27 +8,27 @@ export const lintSingleMessage = async (args) => {
     const reports = [];
     const errors = [];
     const promises = args.rules.map(async (rule) => {
-        const ruleId = rule.meta.id;
-        const settings = args.ruleSettings?.[ruleId] ?? {};
-        const level = args.ruleLevels?.[ruleId];
+        const level = args.settings.messageLintRuleLevels?.[rule.id];
         if (level === undefined) {
-            throw Error("No lint level provided for lint rule: " + ruleId);
+            throw Error("No lint level provided for lint rule: " + rule.id);
         }
         try {
-            await rule.message({
-                ...args,
-                settings,
+            await rule.run({
+                message: args.message,
+                settings: args.settings,
                 report: (reportArgs) => {
                     reports.push({
-                        ruleId,
+                        ruleId: rule.id,
                         level,
-                        ...reportArgs,
+                        messageId: reportArgs.messageId,
+                        languageTag: reportArgs.languageTag,
+                        body: reportArgs.body,
                     });
                 },
             });
         }
         catch (error) {
-            errors.push(new MessagedLintRuleThrowedError(`Lint rule '${ruleId}' throwed while linting message "${args.message.id}".`, { cause: error }));
+            errors.push(new MessagedLintRuleThrowedError(`Lint rule '${rule.id}' throwed while linting message "${args.message.id}".`, { cause: error }));
         }
     });
     await Promise.all(promises);

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

@@ -2,20 +2,16 @@ import { beforeEach, describe, expect, test, vi } from "vitest";
 import { lintSingleMessage } from "./lintSingleMessage.js";
 import { tryCatch } from "@inlang/result";
 const lintRule1 = {
-    meta: {
-        id: "messageLintRule.r.1",
-        displayName: { en: "" },
-        description: { en: "" },
-    },
-    message: vi.fn(),
+    id: "messageLintRule.r.1",
+    displayName: "",
+    description: "",
+    run: vi.fn(),
 };
 const lintRule2 = {
-    meta: {
-        id: "messageLintRule.r.2",
-        displayName: { en: "" },
-        description: { en: "" },
-    },
-    message: vi.fn(),
+    id: "messageLintRule.r.2",
+    displayName: "",
+    description: "",
+    run: vi.fn(),
 };
 const message1 = {};
 const messages = [message1];
@@ -27,12 +23,14 @@ describe("lintSingleMessage", async () => {
         // the lint function is un-opinionated and does not set a default level.
         // opinionated users like the inlang instance can very well set a default level (separation of concerns)
         test("it should throw if a lint level is not provided for a given lint rule", async () => {
-            lintRule1.message.mockImplementation(({ report }) => report({}));
+            lintRule1.run.mockImplementation(({ report }) => report({}));
             const result = await tryCatch(() => lintSingleMessage({
-                ruleLevels: {},
-                ruleSettings: {},
-                sourceLanguageTag: "en",
-                languageTags: ["en"],
+                settings: {
+                    sourceLanguageTag: "en",
+                    languageTags: ["en"],
+                    messageLintRuleLevels: {},
+                    modules: [],
+                },
                 messages,
                 message: message1,
                 rules: [lintRule1],
@@ -41,14 +39,16 @@ describe("lintSingleMessage", async () => {
             expect(result.data).toBeUndefined();
         });
         test("it should override the default lint level", async () => {
-            lintRule1.message.mockImplementation(({ report }) => report({}));
+            lintRule1.run.mockImplementation(({ report }) => report({}));
             const reports = await lintSingleMessage({
-                ruleLevels: {
-                    [lintRule1.meta.id]: "error",
+                settings: {
+                    sourceLanguageTag: "en",
+                    languageTags: ["en"],
+                    modules: [],
+                    messageLintRuleLevels: {
+                        [lintRule1.id]: "error",
+                    },
                 },
-                ruleSettings: {},
-                sourceLanguageTag: "en",
-                languageTags: ["en"],
                 messages,
                 message: message1,
                 rules: [lintRule1],
@@ -56,18 +56,18 @@ describe("lintSingleMessage", async () => {
             expect(reports.data[0]?.level).toBe("error");
         });
         test("it should pass the correct settings", async () => {
-            const settings = {};
-            const fn = vi.fn();
-            lintRule1.message.mockImplementation(({ settings }) => fn(settings));
-            await lintSingleMessage({
-                ruleLevels: {
-                    [lintRule1.meta.id]: "warning",
-                },
-                ruleSettings: {
-                    [lintRule1.meta.id]: settings,
-                },
+            const settings = {
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
+                modules: [],
+                messageLintRuleLevels: {
+                    [lintRule1.id]: "warning",
+                },
+            };
+            const fn = vi.fn();
+            lintRule1.run.mockImplementation(({ settings }) => fn(settings));
+            await lintSingleMessage({
+                settings,
                 messages,
                 message: message1,
                 rules: [lintRule1],
@@ -78,21 +78,23 @@ describe("lintSingleMessage", async () => {
     test("it should await all rules", async () => {
         let m1Called = false;
         let m2Called = false;
-        lintRule1.message.mockImplementation(() => {
+        lintRule1.run.mockImplementation(() => {
             m1Called = true;
         });
-        lintRule2.message.mockImplementation(async () => {
+        lintRule2.run.mockImplementation(async () => {
             await new Promise((resolve) => setTimeout(resolve, 0));
             m2Called = true;
         });
         await lintSingleMessage({
-            ruleLevels: {
-                [lintRule1.meta.id]: "warning",
-                [lintRule2.meta.id]: "warning",
+            settings: {
+                sourceLanguageTag: "en",
+                languageTags: ["en"],
+                modules: [],
+                messageLintRuleLevels: {
+                    [lintRule1.id]: "warning",
+                    [lintRule2.id]: "warning",
+                },
             },
-            ruleSettings: {},
-            sourceLanguageTag: "en",
-            languageTags: ["en"],
             messages,
             message: message1,
             rules: [lintRule1, lintRule2],
@@ -102,49 +104,53 @@ describe("lintSingleMessage", async () => {
     });
     test("it should process all rules in parallel", async () => {
         const fn = vi.fn();
-        lintRule1.message.mockImplementation(async () => {
-            fn(lintRule1.meta.id, "before");
+        lintRule1.run.mockImplementation(async () => {
+            fn(lintRule1.id, "before");
             await new Promise((resolve) => setTimeout(resolve, 0));
-            fn(lintRule1.meta.id, "after");
+            fn(lintRule1.id, "after");
         });
-        lintRule2.message.mockImplementation(async () => {
-            fn(lintRule2.meta.id, "before");
+        lintRule2.run.mockImplementation(async () => {
+            fn(lintRule2.id, "before");
             await new Promise((resolve) => setTimeout(resolve, 0));
-            fn(lintRule2.meta.id, "after");
+            fn(lintRule2.id, "after");
         });
         await lintSingleMessage({
-            ruleLevels: {
-                [lintRule1.meta.id]: "warning",
-                [lintRule2.meta.id]: "warning",
+            settings: {
+                sourceLanguageTag: "en",
+                languageTags: ["en"],
+                modules: [],
+                messageLintRuleLevels: {
+                    [lintRule1.id]: "warning",
+                    [lintRule2.id]: "warning",
+                },
             },
-            ruleSettings: {},
-            sourceLanguageTag: "en",
-            languageTags: ["en"],
             messages,
             message: message1,
             rules: [lintRule1, lintRule2],
         });
         expect(fn).toHaveBeenCalledTimes(4);
-        expect(fn).toHaveBeenNthCalledWith(1, lintRule1.meta.id, "before");
-        expect(fn).toHaveBeenNthCalledWith(2, lintRule2.meta.id, "before");
-        expect(fn).toHaveBeenNthCalledWith(3, lintRule1.meta.id, "after");
-        expect(fn).toHaveBeenNthCalledWith(4, lintRule2.meta.id, "after");
+        expect(fn).toHaveBeenNthCalledWith(1, lintRule1.id, "before");
+        expect(fn).toHaveBeenNthCalledWith(2, lintRule2.id, "before");
+        expect(fn).toHaveBeenNthCalledWith(3, lintRule1.id, "after");
+        expect(fn).toHaveBeenNthCalledWith(4, lintRule2.id, "after");
     });
     test("it should not abort the linting process when errors occur", async () => {
-        lintRule1.message.mockImplementation(() => {
+        lintRule1.run.mockImplementation(() => {
             throw new Error("error");
         });
-        lintRule2.message.mockImplementation(({ report }) => {
+        lintRule2.run.mockImplementation(({ report }) => {
             report({});
         });
         const result = await lintSingleMessage({
-            ruleLevels: {
-                [lintRule1.meta.id]: "warning",
-                [lintRule2.meta.id]: "warning",
+            settings: {
+                sourceLanguageTag: "en",
+                languageTags: ["en"],
+                modules: [],
+                messageLintRuleLevels: {
+                    [lintRule1.id]: "warning",
+                    [lintRule2.id]: "warning",
+                },
             },
-            ruleSettings: {},
-            sourceLanguageTag: "en",
-            languageTags: ["en"],
             messages,
             message: message1,
             rules: [lintRule1, lintRule2],

package/dist/{openInlangProject.d.ts → loadProject.d.ts}

@@ -8,11 +8,11 @@ import { type NodeishFilesystemSubset } from "./versionedInterfaces.js";
  *   and supporting legacy resolvedModules such as CJS.
  *
  */
-export declare const openInlangProject: (args: {
-    projectFilePath: string;
+export declare const loadProject: (args: {
+    settingsFilePath: string;
     nodeishFs: NodeishFilesystemSubset;
     _import?: ImportFunction | undefined;
     _capture?: ((id: string, props: Record<string, unknown>) => void) | undefined;
 }) => Promise<InlangProject>;
 export declare function createSubscribable<T>(signal: () => T): Subscribable<T>;
-//# sourceMappingURL=openInlangProject.d.ts.map
+//# sourceMappingURL=loadProject.d.ts.map

package/dist/loadProject.d.ts.map

@@ -0,0 +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;AAahF,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAMjG;;;;;;GAMG;AACH,eAAO,MAAM,WAAW;sBACL,MAAM;eACb,uBAAuB;;qBAElB,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAmLxB,CAAA;AAsGD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}