@inlang/sdk 0.36.3 → 2.0.0-beta.1

package/dist/createMessagesQuery.test.js

@@ -1,402 +0,0 @@
-/* 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 { Message } from "@inlang/message";
-import { createMessage } from "./test-utilities/createMessage.js";
-import { createNodeishMemoryFs } from "@lix-js/fs";
-const createChangeListener = async (cb) => createEffect(cb);
-const nextTick = () => new Promise((resolve) => setTimeout(resolve, 0));
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const awaitableCreateMessageQuery = async (_messages) => {
-    const fs = createNodeishMemoryFs();
-    const settings = {
-        sourceLanguageTag: "en",
-        languageTags: ["en"],
-        modules: ["plugin.js", "lintRule.js"],
-        messageLintRuleLevels: {
-            "messageLintRule.project.missingTranslation": "error",
-        },
-        "plugin.project.i18next": {
-            pathPattern: "./examples/example01/{languageTag}.json",
-            variableReferencePattern: ["{", "}"],
-        },
-    };
-    let messages = _messages();
-    const resolvedModules = {
-        meta: [],
-        plugins: [],
-        messageLintRules: [],
-        resolvedPluginApi: {
-            loadMessages: (() => {
-                return messages;
-            }),
-            saveMessages: ((newMessages) => {
-                messages = newMessages;
-            }),
-            customApi: {},
-        },
-        errors: [],
-    };
-    return new Promise((res, rej) => {
-        const query = createMessagesQuery({
-            projectPath: "",
-            nodeishFs: fs,
-            settings: () => settings,
-            resolvedModules: () => resolvedModules,
-            onInitialMessageLoadResult: (error) => {
-                if (error) {
-                    rej(error);
-                }
-                else {
-                    res(query);
-                }
-            },
-            onLoadMessageResult: () => { },
-            onSaveMessageResult: () => { },
-        });
-    });
-};
-describe("create", async () => {
-    it("should create a message", async () => {
-        const query = await awaitableCreateMessageQuery(() => []);
-        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("query.getByDefaultAlias should return a message with a default alias", async () => {
-        const query = await awaitableCreateMessageQuery(() => []);
-        expect(query.get({ where: { id: "first-message" } })).toBeUndefined();
-        const mockMessage = createMessage("first-message", { en: "Hello World" });
-        mockMessage.alias = { default: "first-message-alias" };
-        const created = query.create({ data: mockMessage });
-        expect(query.get({ where: { id: "first-message" } })).toEqual(mockMessage);
-        expect(query.getByDefaultAlias("first-message-alias")).toEqual(mockMessage);
-        expect(created).toBe(true);
-    });
-    it("should return false if message with id already exists", async () => {
-        const query = await awaitableCreateMessageQuery(() => [
-            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", async () => {
-    it("should return undefined if a message does not exist", async () => {
-        const query = await awaitableCreateMessageQuery(() => [
-            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", async () => {
-        const query = await awaitableCreateMessageQuery(() => [
-            createMessage("first-message", { en: "Hello World" }),
-        ]);
-        expect(query.get({ where: { id: "first-message" } })).toBeDefined();
-        const mockMessageInit = createMessage("first-message", { en: "Hello World" });
-        query.create({ data: mockMessageInit });
-        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", async () => {
-        const query = await awaitableCreateMessageQuery(() => [
-            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", async () => {
-    it("should return an empty array if no messages exist", async () => {
-        const query = await awaitableCreateMessageQuery(() => []);
-        const messages = query.getAll();
-        expect(Object.values(messages)).toEqual([]);
-    });
-    it("should return all message objects", async () => {
-        const query = await awaitableCreateMessageQuery(() => []);
-        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", async () => {
-        const query = await awaitableCreateMessageQuery(() => [
-            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", async () => {
-    it("should update a message", async () => {
-        const query = await awaitableCreateMessageQuery(() => [
-            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", async () => {
-        const query = await awaitableCreateMessageQuery(() => []);
-        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", async () => {
-    it("should create a message if not present yet", async () => {
-        const query = await awaitableCreateMessageQuery(() => []);
-        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", async () => {
-        const query = await awaitableCreateMessageQuery(() => [
-            createMessage("first-message", { en: "Hello World" }),
-        ]);
-        expect(query.get({ where: { id: "first-message" } })).toBeDefined();
-        const mockMessageInit = createMessage("first-message", { en: "Hello World" });
-        query.create({ data: mockMessageInit });
-        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", async () => {
-    it("should delete a message", async () => {
-        const query = await awaitableCreateMessageQuery(() => [
-            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", async () => {
-        const query = await awaitableCreateMessageQuery(() => []);
-        expect(query.get({ where: { id: "first-message" } })).toBeUndefined();
-        const deleted = query.delete({ where: { id: "first-message" } });
-        expect(deleted).toBe(false);
-    });
-});
-describe("reactivity", async () => {
-    describe("get", async () => {
-        it("should react to `create`", async () => {
-            await createRoot(async () => {
-                const query = await awaitableCreateMessageQuery(() => []);
-                // 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 = await awaitableCreateMessageQuery(() => [
-                    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 = await awaitableCreateMessageQuery(() => []);
-                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 = await awaitableCreateMessageQuery(() => [createMessage("1", { en: "" })]);
-                let message;
-                await createChangeListener(() => (message = query.get({ where: { id: "1" } })));
-                expect(message).toBeDefined();
-                query.delete({ where: { id: "1" } });
-                expect(message).toBeUndefined();
-            });
-        });
-    });
-    describe("subscribe", async () => {
-        describe("get", async () => {
-            it("should subscribe to `create`", async () => {
-                await createRoot(async () => {
-                    const query = await awaitableCreateMessageQuery(() => []);
-                    // eslint-disable-next-line unicorn/no-null
-                    let message = null;
-                    query.get.subscribe({ where: { id: "1" } }, (v) => {
-                        void (message = v);
-                    });
-                    await nextTick();
-                    expect(message).toBeUndefined();
-                    query.create({ data: createMessage("1", { en: "before" }) });
-                    expect(message).toBeDefined();
-                });
-            });
-        });
-        describe("getByDefaultAlias", async () => {
-            it("should subscribe to `create`", async () => {
-                await createRoot(async () => {
-                    const query = await awaitableCreateMessageQuery(() => []);
-                    // eslint-disable-next-line unicorn/no-null
-                    let message = null;
-                    query.getByDefaultAlias.subscribe("message-alias", (v) => {
-                        void (message = v);
-                    });
-                    await nextTick(); // required for effect to run on reactive map
-                    expect(message).toBeUndefined();
-                    const mockMessage = createMessage("1", { en: "before" });
-                    mockMessage.alias = { default: "message-alias" };
-                    query.create({ data: mockMessage });
-                    expect(message).toBeDefined();
-                });
-            });
-        });
-    });
-    describe("getAll", async () => {
-        it("should react to `create`", async () => {
-            await createRoot(async () => {
-                const query = await awaitableCreateMessageQuery(() => []);
-                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 = await awaitableCreateMessageQuery(() => [
-                    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 = await awaitableCreateMessageQuery(() => []);
-                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 = await awaitableCreateMessageQuery(() => [
-                    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 not mutate messages signal outside the query when using the query", async () => {
-            const [inputMessages] = createSignal([createMessage("1", { en: "before" })]);
-            const query = await awaitableCreateMessageQuery(inputMessages);
-            let messages = undefined;
-            await createChangeListener(() => (messages = query.getAll()));
-            expect(Object.values(messages)).toHaveLength(1);
-            query.create({ data: createMessage("2", { en: "" }) });
-            expect(inputMessages().length).toBe(1);
-        });
-    });
-});
-it("instances should not share state", async () => {
-    await createRoot(async () => {
-        const query1 = await awaitableCreateMessageQuery(() => [createMessage("1", { en: "before" })]);
-        const query2 = await awaitableCreateMessageQuery(() => []);
-        // 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/createNewProject.d.ts

@@ -1,12 +0,0 @@
-import type { Repository } from "@lix-js/client";
-import { ProjectSettings } from "@inlang/project-settings";
-/**
- * Creates a new project in the given directory.
- * The directory must be an absolute path, must not exist, and must end with {name}.inlang
- */
-export declare function createNewProject(args: {
-    projectPath: string;
-    repo: Repository;
-    projectSettings: ProjectSettings;
-}): Promise<void>;
-//# sourceMappingURL=createNewProject.d.ts.map

package/dist/createNewProject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createNewProject.d.ts","sourceRoot":"","sources":["../src/createNewProject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAI1D;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,eAAe,EAAE,eAAe,CAAA;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAehB"}

package/dist/createNewProject.js

@@ -1,38 +0,0 @@
-import { ProjectSettings } from "@inlang/project-settings";
-import { assertValidProjectPath } from "./validateProjectPath.js";
-import { defaultProjectSettings } from "./defaultProjectSettings.js";
-/**
- * Creates a new project in the given directory.
- * The directory must be an absolute path, must not exist, and must end with {name}.inlang
- */
-export async function createNewProject(args) {
-    assertValidProjectPath(args.projectPath);
-    const nodeishFs = args.repo.nodeishFs;
-    if (await directoryExists(args.projectPath, nodeishFs)) {
-        throw new Error(`projectPath already exists, received "${args.projectPath}"`);
-    }
-    const settingsText = JSON.stringify(args.projectSettings ?? defaultProjectSettings, undefined, 2);
-    await nodeishFs.mkdir(args.projectPath, { recursive: true });
-    await Promise.all([
-        nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsText),
-        nodeishFs.writeFile(`${args.projectPath}/.gitignore`, "cache"),
-        nodeishFs.mkdir(`${args.projectPath}/cache/modules`, { recursive: true }),
-    ]);
-}
-/**
- * Returns true if the path exists (file or directory), false otherwise.
- */
-async function directoryExists(filePath, nodeishFs) {
-    try {
-        const stat = await nodeishFs.stat(filePath);
-        return stat.isDirectory();
-    }
-    catch (error) {
-        if (error && "code" in error && error.code === "ENOENT") {
-            return false;
-        }
-        else {
-            throw new Error(`Failed to check if path exists: ${error}`, { cause: error });
-        }
-    }
-}

package/dist/createNewProject.test.d.ts

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

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

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

package/dist/createNewProject.test.js

@@ -1,91 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createNewProject } from "./createNewProject.js";
-import { mockRepo } from "@lix-js/client";
-import { defaultProjectSettings } from "./defaultProjectSettings.js";
-import { loadProject } from "./loadProject.js";
-import { createMessage } from "./test-utilities/createMessage.js";
-import { sleep } from "./test-utilities/sleep.js";
-describe("createNewProject", () => {
-    it("should throw if a path does not end with .inlang", async () => {
-        const repo = await mockRepo();
-        const projectPath = "/test/project.inl";
-        try {
-            await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings });
-            // should not reach this point
-            throw new Error("Expected an error");
-        }
-        catch (e) {
-            expect(e.message).toMatch('Expected a path ending in "{name}.inlang" but received "/test/project.inl"');
-        }
-    });
-    it("should throw if projectPath is not an absolute path", async () => {
-        const repo = await mockRepo();
-        const projectPath = "test/project.inlang";
-        try {
-            await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings });
-            // should not reach this point
-            throw new Error("Expected an error");
-        }
-        catch (e) {
-            expect(e.message).toMatch('Expected an absolute path but received "test/project.inlang"');
-        }
-    });
-    it("should throw if the path already exists", async () => {
-        const repo = await mockRepo();
-        const projectPath = "/test/project.inlang";
-        await repo.nodeishFs.mkdir(projectPath, { recursive: true });
-        try {
-            await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings });
-            // should not reach this point
-            throw new Error("Expected an error");
-        }
-        catch (e) {
-            expect(e.message).toMatch('projectPath already exists, received "/test/project.inlang"');
-        }
-    });
-    it("should create default defaultProjectSettings in projectPath", async () => {
-        const repo = await mockRepo();
-        const projectPath = "/test/project.inlang";
-        await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings });
-        const json = await repo.nodeishFs.readFile(`${projectPath}/settings.json`, {
-            encoding: "utf-8",
-        });
-        const settings = JSON.parse(json);
-        expect(settings).toEqual(defaultProjectSettings);
-    });
-    it("should create different projectSettings in projectPath", async () => {
-        const repo = await mockRepo();
-        const projectPath = "/test/project.inlang";
-        const projectSettings = { ...defaultProjectSettings, languageTags: ["en", "de", "fr"] };
-        await createNewProject({ projectPath, repo, projectSettings });
-        const json = await repo.nodeishFs.readFile(`${projectPath}/settings.json`, {
-            encoding: "utf-8",
-        });
-        const settings = JSON.parse(json);
-        expect(settings).toEqual(projectSettings);
-        expect(settings).not.toEqual(defaultProjectSettings);
-    });
-    it("should load the project after creating it", async () => {
-        const repo = await mockRepo();
-        const projectPath = "/test/project.inlang";
-        await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings });
-        const project = await loadProject({ projectPath, repo });
-        expect(project.errors()).toEqual([]);
-    });
-    it("should create messages inside the project directory", async () => {
-        const repo = await mockRepo();
-        const projectPath = "/test/project.inlang";
-        await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings });
-        const project = await loadProject({ projectPath, repo });
-        expect(project.errors()).toEqual([]);
-        const testMessage = createMessage("test", { en: "test message" });
-        project.query.messages.create({ data: testMessage });
-        const messages = project.query.messages.getAll();
-        expect(messages.length).toBe(1);
-        expect(messages[0]).toEqual(testMessage);
-        await sleep(20);
-        const json = await repo.nodeishFs.readFile("/test/messages/en.json", { encoding: "utf-8" });
-        const jsonMessages = JSON.parse(json);
-        expect(jsonMessages["test"]).toEqual("test message");
-    });
-});

package/dist/createNodeishFsWithAbsolutePaths.d.ts

@@ -1,12 +0,0 @@
-import { type NodeishFilesystem } from "@lix-js/fs";
-/**
- * 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 createNodeishFsWithAbsolutePaths: (args: {
-    projectPath: string;
-    nodeishFs: NodeishFilesystem;
-}) => NodeishFilesystem;
-//# sourceMappingURL=createNodeishFsWithAbsolutePaths.d.ts.map

package/dist/createNodeishFsWithAbsolutePaths.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createNodeishFsWithAbsolutePaths.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithAbsolutePaths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGlE;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,SAAU;IACtD,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,iBAAiB,CAAA;CAC5B,KAAG,iBAuCH,CAAA"}

package/dist/createNodeishFsWithAbsolutePaths.js

@@ -1,38 +0,0 @@
-import { normalizePath } from "@lix-js/fs";
-import { isAbsolutePath } from "./validateProjectPath.js";
-/**
- * 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 createNodeishFsWithAbsolutePaths = (args) => {
-    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.projectPath).split("/").slice(0, -1).join("/");
-    const makeAbsolute = (path) => {
-        if (isAbsolutePath(path)) {
-            return normalizePath(path);
-        }
-        return normalizePath(basePath + "/" + path);
-    };
-    return {
-        // @ts-expect-error
-        readFile: (path, options) => args.nodeishFs.readFile(makeAbsolute(path), options),
-        readdir: (path) => args.nodeishFs.readdir(makeAbsolute(path)),
-        mkdir: (path, options) => args.nodeishFs.mkdir(makeAbsolute(path), options),
-        writeFile: (path, data) => args.nodeishFs.writeFile(makeAbsolute(path), data),
-        stat: (path) => args.nodeishFs.stat(makeAbsolute(path)),
-        rm: (path) => args.nodeishFs.rm(makeAbsolute(path)),
-        rmdir: (path) => args.nodeishFs.rmdir(makeAbsolute(path)),
-        watch: (path, options) => args.nodeishFs.watch(makeAbsolute(path), options),
-        // This might be surprising when symlinks were intended to be relative
-        symlink: (target, path) => args.nodeishFs.symlink(makeAbsolute(target), makeAbsolute(path)),
-        unlink: (path) => args.nodeishFs.unlink(makeAbsolute(path)),
-        readlink: (path) => args.nodeishFs.readlink(makeAbsolute(path)),
-        lstat: (path) => args.nodeishFs.lstat(makeAbsolute(path)),
-    };
-};

package/dist/createNodeishFsWithAbsolutePaths.test.d.ts

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

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

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