@inlang/sdk 0.18.0 → 0.19.0

package/dist/loadProject.test.js

@@ -80,11 +80,42 @@ const _import = async (name) => ({
     default: name === "plugin.js" ? mockPlugin : mockMessageLintRule,
 });
 // ------------------------------------------------------------------------------------------------
+/**
+ * Dear Developers,
+ *
+ * Inlang projects (folders) are not like .vscode, .git, or .github folders. Treat em
+ * like files: they can be renamed and moved around.
+ */
+it("should throw if a project (path) does not have a name", async () => {
+    const fs = createNodeishMemoryFs();
+    const project = await tryCatch(() => loadProject({
+        projectPath: "/source-code/.inlang",
+        nodeishFs: fs,
+        _import,
+    }));
+    expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
+});
+it("should throw if a project path does not end with .inlang", async () => {
+    const fs = createNodeishMemoryFs();
+    const invalidPaths = [
+        "/source-code/frontend.inlang/settings",
+        "/source-code/frontend.inlang/settings.json",
+        "/source-code/frontend.inlang.md",
+    ];
+    for (const invalidPath of invalidPaths) {
+        const project = await tryCatch(() => loadProject({
+            projectPath: invalidPath,
+            nodeishFs: fs,
+            _import,
+        }));
+        expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
+    }
+});
 describe("initialization", () => {
-    it("should throw if settingsFilePath is not an absolute path", async () => {
+    it("should throw if projectPath is not an absolute path", async () => {
         const fs = createNodeishMemoryFs();
         const result = await tryCatch(() => loadProject({
-            settingsFilePath: "relative/path",
+            projectPath: "relative/path",
             nodeishFs: fs,
             _import,
         }));
@@ -93,10 +124,10 @@ describe("initialization", () => {
     });
     it("should resolve from a windows path", async () => {
         const fs = createNodeishMemoryFs();
-        fs.mkdir("C:\\Users\\user\\project", { recursive: true });
-        fs.writeFile("C:\\Users\\user\\project\\project.inlang.json", JSON.stringify(settings));
+        fs.mkdir("C:\\Users\\user\\project.inlang", { recursive: true });
+        fs.writeFile("C:\\Users\\user\\project.inlang\\settings.json", JSON.stringify(settings));
         const result = await tryCatch(() => loadProject({
-            settingsFilePath: "C:\\Users\\user\\project\\project.inlang.json",
+            projectPath: "C:\\Users\\user\\project.inlang",
             nodeishFs: fs,
             _import,
         }));
@@ -108,7 +139,7 @@ describe("initialization", () => {
             const fs = createNodeishMemoryFs();
             fs.mkdir("/user/project", { recursive: true });
             const project = await loadProject({
-                settingsFilePath: "/user/project/test.json",
+                projectPath: "/user/non-existend-project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -116,10 +147,10 @@ describe("initialization", () => {
         });
         it("should return an error if settings file is not a valid JSON", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", "invalid json");
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", "invalid json");
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -127,10 +158,10 @@ describe("initialization", () => {
         });
         it("should return an error if settings file is does not match schema", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify({}));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify({}));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -138,10 +169,10 @@ describe("initialization", () => {
         });
         it("should return the parsed settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -150,21 +181,21 @@ describe("initialization", () => {
         it("should not re-write the settings to disk when initializing", async () => {
             const fs = await createNodeishMemoryFs();
             const settingsWithDeifferentFormatting = JSON.stringify(settings, undefined, 4);
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", settingsWithDeifferentFormatting);
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", settingsWithDeifferentFormatting);
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
-            const settingsOnDisk = await fs.readFile("/user/project/project.inlang.json", {
+            const settingsOnDisk = await fs.readFile("/user/project.inlang/settings.json", {
                 encoding: "utf-8",
             });
             expect(settingsOnDisk).toBe(settingsWithDeifferentFormatting);
             project.setSettings(project.settings());
             // TODO: how can we await `setsettings` correctly
             await new Promise((resolve) => setTimeout(resolve, 0));
-            const newsettingsOnDisk = await fs.readFile("/user/project/project.inlang.json", {
+            const newsettingsOnDisk = await fs.readFile("/user/project.inlang/settings.json", {
                 encoding: "utf-8",
             });
             expect(newsettingsOnDisk).not.toBe(settingsWithDeifferentFormatting);
@@ -176,10 +207,10 @@ describe("initialization", () => {
                 default: {},
             });
             const fs = createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import: $badImport,
             });
@@ -204,10 +235,10 @@ describe("functionality", () => {
     describe("settings", () => {
         it("should return the settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -215,10 +246,10 @@ describe("functionality", () => {
         });
         it("should set a new settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -235,12 +266,12 @@ describe("functionality", () => {
         });
     });
     describe("setSettings", () => {
-        it("should fail if settings is not valid", async () => {
+        it("should fail if settings are not valid", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -250,15 +281,15 @@ describe("functionality", () => {
         });
         it("should throw an error if sourceLanguageTag is not in languageTags", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
+            await fs.mkdir("/user/project.inlang", { recursive: true });
             const settings = {
                 sourceLanguageTag: "en",
                 languageTags: ["de"],
                 modules: [],
             };
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -267,21 +298,21 @@ describe("functionality", () => {
         });
         it("should write settings to disk", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
-            const before = await fs.readFile("/user/project/project.inlang.json", { encoding: "utf-8" });
+            const before = await fs.readFile("/user/project.inlang/settings.json", { encoding: "utf-8" });
             expect(before).toBeDefined();
-            const result = project.setSettings({ ...settings, languageTags: ["en"] });
+            const result = project.setSettings({ ...settings, languageTags: ["en", "nl", "de"] });
             expect(result.data).toBeUndefined();
             expect(result.error).toBeUndefined();
             // TODO: how to wait for fs.writeFile to finish?
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            const after = await fs.readFile("/user/project/project.inlang.json", { encoding: "utf-8" });
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            const after = await fs.readFile("/user/project.inlang/settings.json", { encoding: "utf-8" });
             expect(after).toBeDefined();
             expect(after).not.toBe(before);
         });
@@ -294,10 +325,10 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
             };
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -322,10 +353,10 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
             };
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -353,8 +384,8 @@ describe("functionality", () => {
                 saveMessages: () => undefined,
             };
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify({
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify({
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
@@ -365,7 +396,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -395,8 +426,8 @@ describe("functionality", () => {
                 saveMessages: () => undefined,
             };
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify({
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify({
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
@@ -407,7 +438,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -418,10 +449,10 @@ describe("functionality", () => {
     describe("errors", () => {
         it("should return the errors", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -433,10 +464,10 @@ describe("functionality", () => {
     describe("customApi", () => {
         it("should return the app specific api", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -448,10 +479,10 @@ describe("functionality", () => {
     describe("messages", () => {
         it("should return the messages", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -469,8 +500,8 @@ describe("functionality", () => {
                     pathPattern: "./resources/{languageTag}.json",
                 },
             };
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             await fs.mkdir("./resources");
             const mockSaveFn = vi.fn();
             const _mockPlugin = {
@@ -486,7 +517,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -631,7 +662,8 @@ describe("functionality", () => {
                     pathPattern: "./resources/{languageTag}.json",
                 },
             };
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("./project.inlang", { recursive: true });
+            await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings));
             const mockSaveFn = vi.fn();
             const _mockPlugin = {
                 id: "plugin.placeholder.name",
@@ -650,7 +682,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "/project.inlang.json",
+                projectPath: "/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -666,7 +698,7 @@ describe("functionality", () => {
             await fs.mkdir("/user/project", { recursive: true });
             await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -686,10 +718,10 @@ describe("functionality", () => {
                 modules: ["lintRule.js"],
             };
             const fs = createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import: async () => ({
                     default: mockMessageLintRule,
@@ -743,10 +775,11 @@ describe("functionality", () => {
                     filePath: "./messages.json",
                 },
             };
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("./project.inlang", { recursive: true });
+            await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings));
             // establish watcher
             const project = await loadProject({
-                settingsFilePath: normalizePath("/project.inlang.json"),
+                projectPath: normalizePath("/project.inlang"),
                 nodeishFs: fs,
                 _import: async () => ({
                     default: mockMessageFormatPlugin,

package/dist/migrations/migrateToDirectory.d.ts

@@ -0,0 +1,10 @@
+import type { NodeishFilesystem } from "@lix-js/fs";
+/**
+ * Migrates to the new project directory structure
+ * https://github.com/inlang/monorepo/issues/1678
+ */
+export declare const maybeMigrateToDirectory: (args: {
+    nodeishFs: NodeishFilesystem;
+    projectPath: string;
+}) => Promise<void>;
+//# sourceMappingURL=migrateToDirectory.d.ts.map

package/dist/migrations/migrateToDirectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrateToDirectory.d.ts","sourceRoot":"","sources":["../../src/migrations/migrateToDirectory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,SAAgB;IACnD,SAAS,EAAE,iBAAiB,CAAA;IAC5B,WAAW,EAAE,MAAM,CAAA;CACnB,kBA0BA,CAAA"}

package/dist/migrations/migrateToDirectory.js

@@ -0,0 +1,46 @@
+import { tryCatch } from "@inlang/result";
+/**
+ * Migrates to the new project directory structure
+ * https://github.com/inlang/monorepo/issues/1678
+ */
+export const maybeMigrateToDirectory = async (args) => {
+    // the migration assumes that the projectPath ends with project.inlang
+    if (args.projectPath.endsWith("project.inlang") === false) {
+        return;
+    }
+    // we assume that stat will throw when the directory does not exist
+    const projectDirectory = await tryCatch(() => args.nodeishFs.stat(args.projectPath));
+    // the migration has already been conducted.
+    if (projectDirectory.data) {
+        return;
+    }
+    const settingsFile = await tryCatch(() => args.nodeishFs.readFile(args.projectPath + ".json", { encoding: "utf-8" }));
+    // the settings file does not exist or something else is wrong, let loadProject handle it
+    if (settingsFile.error) {
+        return;
+    }
+    await args.nodeishFs.mkdir(args.projectPath);
+    await args.nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsFile.data);
+    await args.nodeishFs.writeFile(args.projectPath + ".README.md", readme);
+};
+const readme = `
+# DELETE THE \`project.inlang.json\` FILE
+
+The \`project.inlang.json\` file is now contained in a project directory e.g. \`project.inlang/settings.json\`.
+
+
+## What you need to do
+
+1. Update the inlang CLI (if you use it) to use the new path \`project.inlang\` instead of \`project.inlang.json\`.
+2. Delete the \`project.inlang.json\` file.
+
+
+## Why is this happening?
+
+See this RFC https://docs.google.com/document/d/1OYyA1wYfQRbIJOIBDliYoWjiUlkFBNxH_U2R4WpVRZ4/edit#heading=h.pecv6xb7ial6 
+and the following GitHub issue for more information https://github.com/inlang/monorepo/issues/1678.
+
+- Monorepo support https://github.com/inlang/monorepo/discussions/258. 
+- Required for many other future features like caching, first class offline support, and more. 
+- Stablize the inlang project format.
+`;

package/dist/migrations/migrateToDirectory.test.d.ts

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

package/dist/migrations/migrateToDirectory.test.d.ts.map

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

package/dist/migrations/migrateToDirectory.test.js

@@ -0,0 +1,48 @@
+import { test, expect, vi } from "vitest";
+import { maybeMigrateToDirectory } from "./migrateToDirectory.js";
+import { createNodeishMemoryFs } from "@lix-js/fs";
+test("it should return if the settings file has an error (let loadProject handle it)", async () => {
+    const projectPath = "./project.inlang";
+    const mockFs = {
+        stat: vi.fn(() => { }),
+        readFile: vi.fn(() => {
+            throw Error();
+        }),
+    };
+    await maybeMigrateToDirectory({ nodeishFs: mockFs, projectPath });
+    // something goes wrong in readFile
+    expect(mockFs.readFile).toHaveBeenCalled();
+});
+test("it should create the project directory if it does not exist and a project settings file exists", async () => {
+    const projectPath = "./project.inlang";
+    const mockFs = {
+        readFile: vi.fn(() => `{
+			"sourceLanguageTag": "en",
+			"languageTags": ["en", "de"],
+			"modules": []
+		}`),
+        stat: vi.fn(() => {
+            throw Error();
+        }),
+        mkdir: vi.fn(),
+        writeFile: vi.fn(),
+    };
+    await maybeMigrateToDirectory({ nodeishFs: mockFs, projectPath });
+    expect(mockFs.mkdir).toHaveBeenCalled();
+    expect(mockFs.writeFile).toHaveBeenCalled();
+});
+test("it should write the settings file to the new path", async () => {
+    const fs = createNodeishMemoryFs();
+    const mockSettings = {
+        sourceLanguageTag: "en",
+        languageTags: ["en", "de"],
+        modules: [],
+    };
+    await fs.writeFile("./project.inlang.json", JSON.stringify(mockSettings));
+    await maybeMigrateToDirectory({ nodeishFs: fs, projectPath: "./project.inlang" });
+    const migratedSettingsFile = await fs.readFile("./project.inlang/settings.json", {
+        encoding: "utf-8",
+    });
+    expect(migratedSettingsFile).toEqual(JSON.stringify(mockSettings));
+    expect(await fs.stat("./project.inlang.README.md")).toBeDefined();
+});

package/dist/resolve-modules/validateModuleSettings.test.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { expect, test } from "vitest";
-import { Plugin, MessageLintRule } from "@inlang/sdk";
+import { Plugin, MessageLintRule } from "../index.js";
 // import { createNodeishMemoryFs } from "@lix-js/fs"
 import { Type } from "@sinclair/typebox";
 import { validatedModuleSettings } from "./validatedModuleSettings.js";