@inlang/sdk 0.17.0 → 0.19.0

package/dist/adapter/solidAdapter.test.js

@@ -72,10 +72,10 @@ const $import = async (name) => ({
 describe("config", () => {
     it("should react to changes in config", async () => {
         const fs = createNodeishMemoryFs();
-        await fs.mkdir("/user/project", { recursive: true });
-        await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(config));
+        await fs.mkdir("/user/project.inlang", { recursive: true });
+        await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config));
         const project = solidAdapter(await loadProject({
-            settingsFilePath: "/user/project/project.inlang.json",
+            projectPath: "/user/project.inlang",
             nodeishFs: fs,
             _import: $import,
         }), { from });
@@ -96,10 +96,10 @@ describe("config", () => {
 describe("installed", () => {
     it("react to changes that are unrelated to installed items", async () => {
         const fs = createNodeishMemoryFs();
-        await fs.mkdir("/user/project", { recursive: true });
-        await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(config));
+        await fs.mkdir("/user/project.inlang", { recursive: true });
+        await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config));
         const project = solidAdapter(await loadProject({
-            settingsFilePath: "/user/project/project.inlang.json",
+            projectPath: "/user/project.inlang",
             nodeishFs: fs,
             _import: $import,
         }), { from });
@@ -149,10 +149,10 @@ describe("messages", () => {
             saveMessages: () => undefined,
         };
         const mockImport = async () => ({ default: mockPlugin });
-        await fs.mkdir("/user/project", { recursive: true });
-        await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(mockConfig));
+        await fs.mkdir("/user/project.inlang.inlang", { recursive: true });
+        await fs.writeFile("/user/project.inlang.inlang/settings.json", JSON.stringify(mockConfig));
         const project = solidAdapter(await loadProject({
-            settingsFilePath: "/user/project/project.inlang.json",
+            projectPath: "/user/project.inlang.inlang",
             nodeishFs: fs,
             _import: mockImport,
         }), { from });
@@ -170,10 +170,10 @@ describe("messages", () => {
     });
     it("should react to changes in messages", async () => {
         const fs = createNodeishMemoryFs();
-        await fs.mkdir("/user/project", { recursive: true });
-        await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(config));
+        await fs.mkdir("/user/project.inlang.inlang", { recursive: true });
+        await fs.writeFile("/user/project.inlang.inlang/settings.json", JSON.stringify(config));
         const project = solidAdapter(await loadProject({
-            settingsFilePath: "/user/project/project.inlang.json",
+            projectPath: "/user/project.inlang.inlang",
             nodeishFs: fs,
             _import: $import,
         }), { from });
@@ -216,9 +216,10 @@ describe("lint", () => {
     it.todo("should react to changes in config", async () => {
         await createRoot(async () => {
             const fs = createNodeishMemoryFs();
-            await fs.writeFile("./project.config.json", JSON.stringify(config));
+            await fs.mkdir("./project.inlang", { recursive: true });
+            await fs.writeFile("./project.inlang/settings.json", JSON.stringify(config));
             const project = solidAdapter(await loadProject({
-                settingsFilePath: "./project.config.json",
+                projectPath: "./project.inlang",
                 nodeishFs: fs,
                 _import: $import,
             }), { from });
@@ -245,7 +246,7 @@ describe("lint", () => {
             const fs = createNodeishMemoryFs();
             await fs.writeFile("./project.config.json", JSON.stringify(config));
             const project = solidAdapter(await loadProject({
-                settingsFilePath: "./project.config.json",
+                projectPath: "./project.config.json",
                 nodeishFs: fs,
                 _import: $import,
             }), { from });

package/dist/createNodeishFsWithAbsolutePaths.d.ts

@@ -3,10 +3,10 @@ import type { NodeishFilesystemSubset } from "@inlang/plugin";
  * Wraps the nodeish filesystem subset with a function that intercepts paths
  * and prepends the base path.
  *
- * The paths are resolved from the `settingsFilePath` argument.
+ * The paths are resolved from the `projectPath` argument.
  */
 export declare const createNodeishFsWithAbsolutePaths: (args: {
-    settingsFilePath: string;
+    projectPath: string;
     nodeishFs: NodeishFilesystemSubset;
 }) => NodeishFilesystemSubset;
 //# sourceMappingURL=createNodeishFsWithAbsolutePaths.d.ts.map

package/dist/createNodeishFsWithAbsolutePaths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createNodeishFsWithAbsolutePaths.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithAbsolutePaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAI7D;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,SAAU;IACtD,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAG,uBAyBH,CAAA"}
+{"version":3,"file":"createNodeishFsWithAbsolutePaths.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithAbsolutePaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAI7D;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,SAAU;IACtD,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAG,uBA6BH,CAAA"}

package/dist/createNodeishFsWithAbsolutePaths.js

@@ -4,15 +4,15 @@ import { isAbsolutePath } from "./isAbsolutePath.js";
  * Wraps the nodeish filesystem subset with a function that intercepts paths
  * and prepends the base path.
  *
- * The paths are resolved from the `settingsFilePath` argument.
+ * The paths are resolved from the `projectPath` argument.
  */
 export const createNodeishFsWithAbsolutePaths = (args) => {
-    if (!isAbsolutePath(args.settingsFilePath)) {
-        throw new Error(`Expected an absolute path but received "${args.settingsFilePath}".`);
+    if (!isAbsolutePath(args.projectPath)) {
+        throw new Error(`Expected an absolute path but received "${args.projectPath}".`);
     }
     // get the base path of the settings file by
     // removing the file name from the path
-    const basePath = normalizePath(args.settingsFilePath).split("/").slice(0, -1).join("/");
+    const basePath = normalizePath(args.projectPath).split("/").slice(0, -1).join("/");
     const makeAbsolute = (path) => {
         if (isAbsolutePath(path)) {
             return normalizePath(path);
@@ -25,5 +25,6 @@ export const createNodeishFsWithAbsolutePaths = (args) => {
         readdir: (path) => args.nodeishFs.readdir(makeAbsolute(path)),
         mkdir: (path) => args.nodeishFs.mkdir(makeAbsolute(path)),
         writeFile: (path, data) => args.nodeishFs.writeFile(makeAbsolute(path), data),
+        watch: (path, options) => args.nodeishFs.watch(makeAbsolute(path), options),
     };
 };

package/dist/createNodeishFsWithAbsolutePaths.test.js

@@ -1,11 +1,11 @@
 import { it, expect, vi } from "vitest";
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
-it("throws an error if settingsFilePath is not an absolute path", () => {
+it("throws an error if projectPath is not an absolute path", () => {
     const relativePath = "relative/path";
-    expect(() => createNodeishFsWithAbsolutePaths({ settingsFilePath: relativePath, nodeishFs: {} })).toThrow();
+    expect(() => createNodeishFsWithAbsolutePaths({ projectPath: relativePath, nodeishFs: {} })).toThrow();
 });
 it("intercepts paths correctly for readFile", async () => {
-    const settingsFilePath = `/Users/samuel/Documents/paraglide/example/project.inlang.json`;
+    const projectPath = `/Users/samuel/Documents/paraglide/example/project.inlang`;
     const filePaths = [
         ["file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
         ["./file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
@@ -20,9 +20,10 @@ it("intercepts paths correctly for readFile", async () => {
         readdir: vi.fn(),
         mkdir: vi.fn(),
         writeFile: vi.fn(),
+        watch: vi.fn(),
     };
     const interceptedFs = createNodeishFsWithAbsolutePaths({
-        settingsFilePath,
+        projectPath,
         nodeishFs: mockNodeishFs,
     });
     for (const [path, expectedPath] of filePaths) {

package/dist/createNodeishFsWithWatcher.d.ts

@@ -0,0 +1,12 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin";
+/**
+ * Wraps the nodeish filesystem subset with a function that intercepts paths
+ * and prepends the base path.
+ *
+ * The paths are resolved from the `projectPath` argument.
+ */
+export declare const createNodeishFsWithWatcher: (args: {
+    nodeishFs: NodeishFilesystemSubset;
+    updateMessages: () => void;
+}) => NodeishFilesystemSubset;
+//# sourceMappingURL=createNodeishFsWithWatcher.d.ts.map

package/dist/createNodeishFsWithWatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNodeishFsWithWatcher.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithWatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,SAAU;IAChD,SAAS,EAAE,uBAAuB,CAAA;IAClC,cAAc,EAAE,MAAM,IAAI,CAAA;CAC1B,KAAG,uBA8CH,CAAA"}

package/dist/createNodeishFsWithWatcher.js

@@ -0,0 +1,52 @@
+/**
+ * Wraps the nodeish filesystem subset with a function that intercepts paths
+ * and prepends the base path.
+ *
+ * The paths are resolved from the `projectPath` argument.
+ */
+export const createNodeishFsWithWatcher = (args) => {
+    const pathList = [];
+    const makeWatcher = (path) => {
+        const abortController = new AbortController();
+        (async () => {
+            try {
+                const watcher = args.nodeishFs.watch(path, {
+                    signal: abortController.signal,
+                    persistent: false,
+                });
+                if (watcher) {
+                    //eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    for await (const event of watcher) {
+                        args.updateMessages();
+                    }
+                }
+            }
+            catch (err) {
+                if (err.name === "AbortError")
+                    return;
+                // https://github.com/inlang/monorepo/issues/1647
+                // the file does not exist (yet)
+                // this is not testable beacause the fs.watch api differs
+                // from node and lix. lenghty
+                else if (err.code === "ENOENT")
+                    return;
+                throw err;
+            }
+        })();
+    };
+    const readFileAndExtractPath = (path, options) => {
+        if (!pathList.includes(path)) {
+            makeWatcher(path);
+            pathList.push(path);
+        }
+        return args.nodeishFs.readFile(path, options);
+    };
+    return {
+        // @ts-expect-error
+        readFile: (path, options) => readFileAndExtractPath(path, options),
+        readdir: args.nodeishFs.readdir,
+        mkdir: args.nodeishFs.mkdir,
+        writeFile: args.nodeishFs.writeFile,
+        watch: args.nodeishFs.watch,
+    };
+};

package/dist/createNodeishFsWithWatcher.test.d.ts

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

package/dist/createNodeishFsWithWatcher.test.d.ts.map

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

package/dist/createNodeishFsWithWatcher.test.js

@@ -0,0 +1,32 @@
+import { createNodeishMemoryFs } from "@lix-js/fs";
+import { describe, it, expect } from "vitest";
+import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js";
+describe("watcher", () => {
+    it("should trigger the update function when file changes", async () => {
+        let counter = 0;
+        const fs = createNodeishFsWithWatcher({
+            nodeishFs: createNodeishMemoryFs(),
+            updateMessages: () => {
+                counter++;
+            },
+        });
+        // establish watcher
+        await fs.writeFile("file.txt", "a");
+        await fs.readFile("file.txt", { encoding: "utf-8" });
+        expect(counter).toBe(0);
+        // initial file change
+        await fs.writeFile("file.txt", "b");
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(counter).toBe(1);
+        // change file
+        await fs.writeFile("file.txt", "a");
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        //check if update function was called
+        expect(counter).toBe(2);
+        // change file
+        await fs.readFile("file.txt");
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        //check if update function was called
+        expect(counter).toBe(2);
+    });
+});

package/dist/isAbsolutePath.test.js

@@ -8,7 +8,7 @@ describe("isAbsolutePath", () => {
     });
     it("should correctly identify Windows absolute paths", () => {
         assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"));
-        assert.isTrue(isAbsolutePath("C:/Users/user/project/project.inlang.json"));
+        assert.isTrue(isAbsolutePath("C:/Users/user/project.inlang/settings.json"));
         assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"));
     });
     it("should handle edge cases", () => {

package/dist/loadProject.d.ts

@@ -1,10 +1,10 @@
 import type { InlangProject, Subscribable } from "./api.js";
 import { type ImportFunction } from "./resolve-modules/index.js";
-import { type NodeishFilesystemSubset } from "./versionedInterfaces.js";
+import { type NodeishFilesystem } from "@lix-js/fs";
 /**
  * Creates an inlang instance.
  *
- * @param settingsFilePath - Absolute path to the inlang settings file.
+ * @param projectPath - Absolute path to the inlang settings file.
  * @param nodeishFs - Filesystem that implements the NodeishFilesystemSubset interface.
  * @param _import - Use `_import` to pass a custom import function for testing,
  *   and supporting legacy resolvedModules such as CJS.
@@ -12,8 +12,8 @@ import { type NodeishFilesystemSubset } from "./versionedInterfaces.js";
  *
  */
 export declare const loadProject: (args: {
-    settingsFilePath: string;
-    nodeishFs: NodeishFilesystemSubset;
+    projectPath: string;
+    nodeishFs: NodeishFilesystem;
     _import?: ImportFunction | undefined;
     _capture?: ((id: string, props: Record<string, unknown>) => void) | undefined;
 }) => Promise<InlangProject>;

package/dist/loadProject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAchF,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AASjG;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;sBACL,MAAM;eACb,uBAAuB;;qBAElB,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAuMxB,CAAA;AAuHD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}
+{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAkBhF,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAOlE;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;iBACV,MAAM;eACR,iBAAiB;;qBAEZ,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAkOxB,CAAA;AAwHD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/loadProject.js

@@ -11,11 +11,13 @@ import { migrateIfOutdated } from "@inlang/project-settings/migration";
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
 import { normalizePath } from "@lix-js/fs";
 import { isAbsolutePath } from "./isAbsolutePath.js";
+import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js";
+import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js";
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
 /**
  * Creates an inlang instance.
  *
- * @param settingsFilePath - Absolute path to the inlang settings file.
+ * @param projectPath - Absolute path to the inlang settings file.
  * @param nodeishFs - Filesystem that implements the NodeishFilesystemSubset interface.
  * @param _import - Use `_import` to pass a custom import function for testing,
  *   and supporting legacy resolvedModules such as CJS.
@@ -23,25 +25,30 @@ const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
  *
  */
 export const loadProject = async (args) => {
+    const projectPath = normalizePath(args.projectPath);
+    // -- migrate if outdated ------------------------------------------------
+    await maybeMigrateToDirectory({ nodeishFs: args.nodeishFs, projectPath });
     // -- validation --------------------------------------------------------
-    //! the only place where throwing is acceptable because the project
-    //! won't even be loaded. do not throw anywhere else. otherwise, apps
-    //! can't handle errors gracefully.
-    if (!isAbsolutePath(args.settingsFilePath)) {
-        throw new LoadProjectInvalidArgument(`Expected an absolute path but received "${args.settingsFilePath}".`, { argument: "settingsFilePath" });
+    // the only place where throwing is acceptable because the project
+    // won't even be loaded. do not throw anywhere else. otherwise, apps
+    // can't handle errors gracefully.
+    if (!isAbsolutePath(args.projectPath)) {
+        throw new LoadProjectInvalidArgument(`Expected an absolute path but received "${args.projectPath}".`, { argument: "projectPath" });
+    }
+    else if (/[^\\/]+\.inlang$/.test(projectPath) === false) {
+        throw new LoadProjectInvalidArgument(`Expected a path ending in "{name}.inlang" but received "${projectPath}".\n\nValid examples: \n- "/path/to/micky-mouse.inlang"\n- "/path/to/green-elephant.inlang\n`, { argument: "projectPath" });
     }
-    const settingsFilePath = normalizePath(args.settingsFilePath);
     // -- load project ------------------------------------------------------
     return await createRoot(async () => {
         const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
         const nodeishFs = createNodeishFsWithAbsolutePaths({
-            settingsFilePath,
+            projectPath,
             nodeishFs: args.nodeishFs,
         });
         // -- settings ------------------------------------------------------------
         const [settings, _setSettings] = createSignal();
         createEffect(() => {
-            loadSettings({ settingsFilePath, nodeishFs })
+            loadSettings({ settingsFilePath: projectPath + "/settings.json", nodeishFs })
                 .then((settings) => {
                 setSettings(settings);
                 // rename settings to get a convenient access to the data in Posthog
@@ -53,7 +60,7 @@ export const loadProject = async (args) => {
             });
         });
         // TODO: create FS watcher and update settings on change
-        const writeSettingsToDisk = skipFirst((settings) => _writeSettingsToDisk({ nodeishFs, settings }));
+        const writeSettingsToDisk = skipFirst((settings) => _writeSettingsToDisk({ nodeishFs, settings, projectPath }));
         const setSettings = (settings) => {
             try {
                 const validatedSettings = parseSettings(settings);
@@ -95,14 +102,24 @@ export const loadProject = async (args) => {
                 markInitAsFailed(undefined);
                 return;
             }
-            makeTrulyAsync(_resolvedModules.resolvedPluginApi.loadMessages({
-                settings: settingsValue,
-            }))
-                .then((messages) => {
-                setMessages(messages);
-                markInitAsComplete();
-            })
-                .catch((err) => markInitAsFailed(new PluginLoadMessagesError({ cause: err })));
+            const loadAndSetMessages = async (fs) => {
+                makeTrulyAsync(_resolvedModules.resolvedPluginApi.loadMessages({
+                    settings: settingsValue,
+                    nodeishFs: fs,
+                }))
+                    .then((messages) => {
+                    setMessages(messages);
+                    markInitAsComplete();
+                })
+                    .catch((err) => markInitAsFailed(new PluginLoadMessagesError({ cause: err })));
+            };
+            const fsWithWatcher = createNodeishFsWithWatcher({
+                nodeishFs: nodeishFs,
+                updateMessages: () => {
+                    loadAndSetMessages(nodeishFs);
+                },
+            });
+            loadAndSetMessages(fsWithWatcher);
         });
         // -- installed items ----------------------------------------------------
         const installedMessageLintRules = () => {
@@ -135,18 +152,22 @@ export const loadProject = async (args) => {
         const lintReportsQuery = createMessageLintReportsQuery(messages, settings, installedMessageLintRules, resolvedModules);
         const debouncedSave = skipFirst(debounce(500, async (newMessages) => {
             try {
-                await resolvedModules()?.resolvedPluginApi.saveMessages({
-                    settings: settingsValue,
-                    messages: newMessages,
-                });
+                if (JSON.stringify(newMessages) !== JSON.stringify(messages())) {
+                    await resolvedModules()?.resolvedPluginApi.saveMessages({
+                        settings: settingsValue,
+                        messages: newMessages,
+                    });
+                }
             }
             catch (err) {
                 throw new PluginSaveMessagesError({
                     cause: err,
                 });
             }
+            const abortController = new AbortController();
             if (newMessages.length !== 0 &&
-                JSON.stringify(newMessages) !== JSON.stringify(messages())) {
+                JSON.stringify(newMessages) !== JSON.stringify(messages()) &&
+                nodeishFs.watch("/", { signal: abortController.signal }) === undefined) {
                 setMessages(newMessages);
             }
         }, { atBegin: false }));
@@ -225,7 +246,7 @@ const _writeSettingsToDisk = async (args) => {
     if (serializeSettingsError) {
         throw serializeSettingsError;
     }
-    const { error: writeSettingsError } = await tryCatch(async () => args.nodeishFs.writeFile("./project.inlang.json", serializedSettings));
+    const { error: writeSettingsError } = await tryCatch(async () => args.nodeishFs.writeFile(args.projectPath + "/settings.json", serializedSettings));
     if (writeSettingsError) {
         throw writeSettingsError;
     }