@inlang/sdk 0.31.0 → 0.33.0

package/dist/createNewProject.d.ts

@@ -0,0 +1,17 @@
+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
+ * Uses defaultProjectSettings unless projectSettings are provided.
+ *
+ * @param projectPath - Absolute path to the [name].inlang directory
+ * @param repo - An instance of a lix repo as returned by `openRepository`
+ * @param projectSettings - Optional project settings to use for the new project.
+ */
+export declare function createNewProject(args: {
+    projectPath: string;
+    repo: Repository;
+    projectSettings: ProjectSettings;
+}): Promise<void>;
+//# sourceMappingURL=createNewProject.d.ts.map

package/dist/createNewProject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNewProject.d.ts","sourceRoot":"","sources":["../src/createNewProject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAI1D;;;;;;;;GAQG;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,CAYhB"}

package/dist/createNewProject.js

@@ -0,0 +1,22 @@
+import { ProjectSettings } from "@inlang/project-settings";
+import { assertValidProjectPath, pathExists } 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
+ * Uses defaultProjectSettings unless projectSettings are provided.
+ *
+ * @param projectPath - Absolute path to the [name].inlang directory
+ * @param repo - An instance of a lix repo as returned by `openRepository`
+ * @param projectSettings - Optional project settings to use for the new project.
+ */
+export async function createNewProject(args) {
+    assertValidProjectPath(args.projectPath);
+    const nodeishFs = args.repo.nodeishFs;
+    if (await pathExists(args.projectPath, nodeishFs)) {
+        throw new Error(`projectPath already exists, received "${args.projectPath}"`);
+    }
+    await nodeishFs.mkdir(args.projectPath, { recursive: true });
+    const settingsText = JSON.stringify(args.projectSettings ?? defaultProjectSettings, undefined, 2);
+    await nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsText);
+}

package/dist/createNewProject.test.d.ts

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

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

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

package/dist/createNewProject.test.js

@@ -0,0 +1,93 @@
+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";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+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().length).toBe(0);
+    });
+    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().length).toBe(0);
+        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.js

@@ -1,5 +1,5 @@
 import { normalizePath } from "@lix-js/fs";
-import { isAbsolutePath } from "./isAbsolutePath.js";
+import { isAbsolutePath } from "./validateProjectPath.js";
 /**
  * Wraps the nodeish filesystem subset with a function that intercepts paths
  * and prepends the base path.

package/dist/defaultProjectSettings.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Default project settings for createNewProject
+ * from paraglide-js/src/cli/commands/init/defaults.ts
+ */
+export declare const defaultProjectSettings: {
+    $schema: "https://inlang.com/schema/project-settings";
+    sourceLanguageTag: string;
+    languageTags: string[];
+    modules: string[];
+    "plugin.inlang.messageFormat": {
+        pathPattern: string;
+    };
+};
+//# sourceMappingURL=defaultProjectSettings.d.ts.map

package/dist/defaultProjectSettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultProjectSettings.d.ts","sourceRoot":"","sources":["../src/defaultProjectSettings.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;CAoBR,CAAA"}

package/dist/defaultProjectSettings.js

@@ -0,0 +1,23 @@
+/**
+ * Default project settings for createNewProject
+ * from paraglide-js/src/cli/commands/init/defaults.ts
+ */
+export const defaultProjectSettings = {
+    $schema: "https://inlang.com/schema/project-settings",
+    sourceLanguageTag: "en",
+    languageTags: ["en"],
+    modules: [
+        // for instant gratification, we're adding common rules
+        "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-empty-pattern@latest/dist/index.js",
+        "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-missing-translation@latest/dist/index.js",
+        "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-without-source@latest/dist/index.js",
+        "https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-valid-js-identifier@latest/dist/index.js",
+        // default to the message format plugin because it supports all features
+        "https://cdn.jsdelivr.net/npm/@inlang/plugin-message-format@latest/dist/index.js",
+        // the m function matcher should be installed by default in case Sherlock (VS Code extension) is adopted
+        "https://cdn.jsdelivr.net/npm/@inlang/plugin-m-function-matcher@latest/dist/index.js",
+    ],
+    "plugin.inlang.messageFormat": {
+        pathPattern: "./messages/{languageTag}.json",
+    },
+};

package/dist/index.d.ts

@@ -5,6 +5,8 @@
  */
 export type { InlangProject, InstalledMessageLintRule, InstalledPlugin, MessageQueryApi, Subscribable, } from "./api.js";
 export { type ImportFunction, createImport } from "./resolve-modules/index.js";
+export { createNewProject } from "./createNewProject.js";
+export { defaultProjectSettings } from "./defaultProjectSettings.js";
 export { loadProject } from "./loadProject.js";
 export { listProjects } from "./listProjects.js";
 export { solidAdapter, type InlangProjectWithSolidAdapter } from "./adapter/solidAdapter.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACX,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,YAAY,GACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,KAAK,6BAA6B,EAAE,MAAM,2BAA2B,CAAA;AAC5F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EACN,kCAAkC,EAClC,gCAAgC,EAChC,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,GACvB,MAAM,aAAa,CAAA;AAEpB,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACX,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,YAAY,GACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,KAAK,6BAA6B,EAAE,MAAM,2BAA2B,CAAA;AAC5F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EACN,kCAAkC,EAClC,gCAAgC,EAChC,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,GACvB,MAAM,aAAa,CAAA;AAEpB,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/index.js

@@ -4,6 +4,8 @@
  *! EXPORT AS LITTLE AS POSSIBLE TO MINIMIZE THE CHANCE OF BREAKING CHANGES.
  */
 export { createImport } from "./resolve-modules/index.js";
+export { createNewProject } from "./createNewProject.js";
+export { defaultProjectSettings } from "./defaultProjectSettings.js";
 export { loadProject } from "./loadProject.js";
 export { listProjects } from "./listProjects.js";
 export { solidAdapter } from "./adapter/solidAdapter.js";

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;AAyBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAgChD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CAqYzB;AAsHD,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;AAwBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAgChD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CA2XzB;AAsHD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/loadProject.js

@@ -1,6 +1,6 @@
 import { resolveModules } from "./resolve-modules/index.js";
 import { TypeCompiler, ValueErrorType } from "@sinclair/typebox/compiler";
-import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginSaveMessagesError, LoadProjectInvalidArgument, PluginLoadMessagesError, } from "./errors.js";
+import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginSaveMessagesError, PluginLoadMessagesError, } from "./errors.js";
 import { createRoot, createSignal, createEffect } from "./reactivity/solid.js";
 import { createMessagesQuery } from "./createMessagesQuery.js";
 import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.js";
@@ -9,7 +9,7 @@ import { tryCatch } from "@inlang/result";
 import { migrateIfOutdated } from "@inlang/project-settings/migration";
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
 import { normalizePath } from "@lix-js/fs";
-import { isAbsolutePath } from "./isAbsolutePath.js";
+import { assertValidProjectPath } from "./validateProjectPath.js";
 import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js";
 import { stringifyMessage as stringifyMessage } from "./storage/helper.js";
 import { humanIdHash } from "./storage/human-id/human-readable-id.js";
@@ -43,12 +43,7 @@ export async function loadProject(args) {
     // 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" });
-    }
+    assertValidProjectPath(projectPath);
     const nodeishFs = createNodeishFsWithAbsolutePaths({
         projectPath,
         nodeishFs: args.repo.nodeishFs,

package/dist/loadProject.test.js

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect, vi } from "vitest";
 import { loadProject } from "./loadProject.js";
-import { LoadProjectInvalidArgument, ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
+import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
 import { normalizePath } from "@lix-js/fs";
 import { createMessage } from "./test-utilities/createMessage.js";
 import { tryCatch } from "@inlang/result";
@@ -144,7 +144,7 @@ it("should throw if a project (path) does not have a name", async () => {
         repo,
         _import,
     }));
-    expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
+    expect(project?.error?.message).toMatch('Expected a path ending in "{name}.inlang" but received ');
 });
 it("should throw if a project path does not end with .inlang", async () => {
     const repo = await mockRepo();
@@ -159,7 +159,7 @@ it("should throw if a project path does not end with .inlang", async () => {
             repo,
             _import,
         }));
-        expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
+        expect(project.error?.message).toMatch('Expected a path ending in "{name}.inlang" but received ');
     }
 });
 describe("initialization", () => {
@@ -170,7 +170,7 @@ describe("initialization", () => {
             repo,
             _import,
         }));
-        expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument);
+        expect(result.error?.message).toBe('Expected an absolute path but received "relative/path".');
         expect(result.data).toBeUndefined();
     });
     it("should generate projectId on missing projectid", async () => {

package/dist/migrations/maybeCreateFirstProjectId.test.js

@@ -1,7 +1,6 @@
 import { generateProjectId } from "./maybeCreateFirstProjectId.js";
 import { it, expect } from "vitest";
-import { openRepository } from "@lix-js/client/src/openRepository.ts";
-import { mockRepo, createNodeishMemoryFs } from "@lix-js/client";
+import { mockRepo } from "@lix-js/client";
 import {} from "@lix-js/fs";
 // eslint-disable-next-line no-restricted-imports -- test
 import { readFileSync } from "node:fs";
@@ -16,11 +15,9 @@ it("should generate a project id", async () => {
     expect(projectId).toBe("432d7ef29c510e99d95e2d14ef57a0797a1603859b5a851b7dff7e77161b8c08");
 });
 it("should return undefined if repoMeta contains error", async () => {
-    const repoWithError = await openRepository("https://github.com/inlang/no-exist", {
-        nodeishFs: createNodeishMemoryFs(),
-    });
+    await repo.nodeishFs.rm("/.git", { recursive: true });
     const projectId = await generateProjectId({
-        repo: repoWithError,
+        repo: repo,
         projectPath: "mocked_project_path",
     });
     expect(projectId).toBeUndefined();

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

@@ -1 +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"}
+{"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,kBA6BA,CAAA"}

package/dist/migrations/migrateToDirectory.js

@@ -22,6 +22,8 @@ export const maybeMigrateToDirectory = async (args) => {
     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);
+    // eslint-disable-next-line no-console
+    // console.log("🔔 migrated project.inlang to directory")
 };
 const readme = `
 # DELETE THE \`project.inlang.json\` FILE

package/dist/validateProjectPath.d.ts

@@ -0,0 +1,23 @@
+import type { NodeishFilesystem } from "@lix-js/fs";
+/**
+ * validate that a project path is absolute and ends with {name}.inlang.
+ *
+ * @throws if the path is not valid.
+ */
+export declare function assertValidProjectPath(projectPath: string): void;
+/**
+ * tests whether a path ends with {name}.inlang
+ * (does not remove trailing slash)
+ */
+export declare function isInlangProjectPath(path: string): boolean;
+/**
+ * tests whether a path starts with a forward slash (/) or a windows-style
+ * drive letter (C: or D:, etc.) followed by a slash
+ */
+export declare function isAbsolutePath(path: string): boolean;
+/**
+ * Returns true if the path exists (file or directory), false otherwise.
+ *
+ */
+export declare function pathExists(filePath: string, nodeishFs: NodeishFilesystem): Promise<boolean>;
+//# sourceMappingURL=validateProjectPath.d.ts.map

package/dist/validateProjectPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateProjectPath.d.ts","sourceRoot":"","sources":["../src/validateProjectPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,QASzD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,WAE/C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,WAO1C;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,oBAc9E"}

package/dist/validateProjectPath.js

@@ -0,0 +1,52 @@
+/**
+ * validate that a project path is absolute and ends with {name}.inlang.
+ *
+ * @throws if the path is not valid.
+ */
+export function assertValidProjectPath(projectPath) {
+    if (!isAbsolutePath(projectPath)) {
+        throw new Error(`Expected an absolute path but received "${projectPath}".`);
+    }
+    if (!isInlangProjectPath(projectPath)) {
+        throw new Error(`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`);
+    }
+}
+/**
+ * tests whether a path ends with {name}.inlang
+ * (does not remove trailing slash)
+ */
+export function isInlangProjectPath(path) {
+    return /[^\\/]+\.inlang$/.test(path);
+}
+/**
+ * tests whether a path starts with a forward slash (/) or a windows-style
+ * drive letter (C: or D:, etc.) followed by a slash
+ */
+export function isAbsolutePath(path) {
+    return /^\/|^[A-Za-z]:[\\/]/.test(path);
+    // OG from sdk/src/isAbsolutePath.ts - TODO: find out where this regex came from
+    // const matchPosixAndWindowsAbsolutePaths =
+    // 	/^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/
+    // return matchPosixAndWindowsAbsolutePaths.test(path)
+}
+/**
+ * Returns true if the path exists (file or directory), false otherwise.
+ *
+ */
+export async function pathExists(filePath, nodeishFs) {
+    // from paraglide-js/src/services/file-handling/exists.ts
+    // TODO: add fs.exists to @lix-js/fs
+    try {
+        await nodeishFs.stat(filePath);
+        return true;
+    }
+    catch (error) {
+        //@ts-ignore
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        else {
+            throw new Error(`Failed to check if path exists: ${error}`, { cause: error });
+        }
+    }
+}

package/dist/validateProjectPath.test.d.ts

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

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

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

package/dist/validateProjectPath.test.js

@@ -0,0 +1,56 @@
+import { assert, describe, expect, it } from "vitest";
+import { assertValidProjectPath, isAbsolutePath, isInlangProjectPath, pathExists, } from "./validateProjectPath.js";
+import { mockRepo } from "@lix-js/client";
+describe("isAbsolutePath", () => {
+    it("should correctly identify Unix absolute paths", () => {
+        assert.isTrue(isAbsolutePath("/home/user/documents/file.txt"));
+        assert.isTrue(isAbsolutePath("/usr/local/bin/script.sh"));
+        assert.isFalse(isAbsolutePath("relative/path/to/file.txt"));
+    });
+    it("should correctly identify Windows absolute paths", () => {
+        assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"));
+        assert.isTrue(isAbsolutePath("C:/Users/user/project.inlang/settings.json"));
+        assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"));
+    });
+    it("should handle edge cases", () => {
+        assert.isFalse(isAbsolutePath("")); // Empty path should return false
+        assert.isFalse(isAbsolutePath("relative/path/../file.txt")); // Relative path with ".." should return false
+        assert.isFalse(isAbsolutePath("../relative/path/to/file.txt"));
+        assert.isFalse(isAbsolutePath("./relative/path/to/file.txt"));
+    });
+});
+describe("isInlangProjectPath", () => {
+    it("should correctly identify valid inlang project paths", () => {
+        assert.isTrue(isInlangProjectPath("/path/to/orange-mouse.inlang"));
+        assert.isFalse(isInlangProjectPath("relative/path/to/file.txt"));
+        assert.isFalse(isInlangProjectPath("/path/to/.inlang"));
+        assert.isFalse(isInlangProjectPath("/path/to/white-elephant.inlang/"));
+        assert.isFalse(isInlangProjectPath("/path/to/blue-elephant.inlang/settings.json"));
+    });
+});
+describe("assertValidProjectPath", () => {
+    it("should not throw for valid project paths", () => {
+        assert.doesNotThrow(() => assertValidProjectPath("/path/to/brown-mouse.inlang"));
+        assert.doesNotThrow(() => assertValidProjectPath("/path/to/green-elephant.inlang"));
+    });
+    it("should throw for invalid project paths", () => {
+        assert.throws(() => assertValidProjectPath("relative/path/to/flying-lizard.inlang"));
+        assert.throws(() => assertValidProjectPath("/path/to/loud-mouse.inlang/"));
+        assert.throws(() => assertValidProjectPath("/path/to/green-elephant.inlang/settings.json"));
+    });
+});
+// moar tests in paraglide-js/src/services/file-handling/exists.test.ts
+describe("pathExists", () => {
+    it("should work for files", async () => {
+        const repo = await mockRepo();
+        await repo.nodeishFs.writeFile("/test.txt", "hello");
+        expect(await pathExists("/test.txt", repo.nodeishFs)).toBe(true);
+        expect(await pathExists("/does-not-exist.txt", repo.nodeishFs)).toBe(false);
+    });
+    it("should work for directories", async () => {
+        const repo = await mockRepo();
+        await repo.nodeishFs.mkdir("/test/project.inlang", { recursive: true });
+        expect(await pathExists("/test/project.inlang", repo.nodeishFs)).toBe(true);
+        expect(await pathExists("/test/white-gorilla.inlang", repo.nodeishFs)).toBe(false);
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.31.0",
+  "version": "0.33.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -35,13 +35,13 @@
     "@inlang/json-types": "1.1.0",
     "@inlang/language-tag": "1.5.1",
     "@inlang/message": "2.1.0",
+    "@inlang/message-lint-rule": "1.4.5",
     "@inlang/module": "1.2.9",
-    "@inlang/project-settings": "2.4.0",
-    "@inlang/result": "1.1.0",
     "@inlang/plugin": "2.4.9",
-    "@inlang/message-lint-rule": "1.4.5",
-    "@lix-js/client": "1.2.0",
+    "@inlang/result": "1.1.0",
+    "@inlang/project-settings": "2.4.0",
     "@inlang/translatable": "1.3.1",
+    "@lix-js/client": "1.2.1",
     "@lix-js/fs": "1.0.0"
   },
   "devDependencies": {

package/src/api.ts

@@ -80,7 +80,7 @@ export type MessageQueryApi = {
 	}
 	includedMessageIds: Subscribable<Message["id"][]>
 	/*
-	 * getAll is depricated do not use it
+	 * getAll is deprecated do not use it
 	 */
 	getAll: Subscribable<Readonly<Message[]>>
 	update: (args: { where: { id: Message["id"] }; data: Partial<Message> }) => boolean

package/src/createNewProject.test.ts

@@ -0,0 +1,108 @@
+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"
+
+function sleep(ms: number) {
+	return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+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 as Error).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 as Error).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 as Error).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().length).toBe(0)
+	})
+
+	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().length).toBe(0)
+
+		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/src/createNewProject.ts

@@ -0,0 +1,31 @@
+import type { Repository } from "@lix-js/client"
+import { ProjectSettings } from "@inlang/project-settings"
+import { assertValidProjectPath, pathExists } 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
+ * Uses defaultProjectSettings unless projectSettings are provided.
+ *
+ * @param projectPath - Absolute path to the [name].inlang directory
+ * @param repo - An instance of a lix repo as returned by `openRepository`
+ * @param projectSettings - Optional project settings to use for the new project.
+ */
+export async function createNewProject(args: {
+	projectPath: string
+	repo: Repository
+	projectSettings: ProjectSettings
+}): Promise<void> {
+	assertValidProjectPath(args.projectPath)
+
+	const nodeishFs = args.repo.nodeishFs
+	if (await pathExists(args.projectPath, nodeishFs)) {
+		throw new Error(`projectPath already exists, received "${args.projectPath}"`)
+	}
+	await nodeishFs.mkdir(args.projectPath, { recursive: true })
+
+	const settingsText = JSON.stringify(args.projectSettings ?? defaultProjectSettings, undefined, 2)
+
+	await nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsText)
+}

package/src/createNodeishFsWithAbsolutePaths.ts

@@ -1,5 +1,5 @@
 import { normalizePath, type NodeishFilesystem } from "@lix-js/fs"
-import { isAbsolutePath } from "./isAbsolutePath.js"
+import { isAbsolutePath } from "./validateProjectPath.js"
 
 /**
  * Wraps the nodeish filesystem subset with a function that intercepts paths

package/src/defaultProjectSettings.ts

@@ -0,0 +1,27 @@
+import type { ProjectSettings } from "@inlang/project-settings"
+
+/**
+ * Default project settings for createNewProject
+ * from paraglide-js/src/cli/commands/init/defaults.ts
+ */
+export const defaultProjectSettings = {
+	$schema: "https://inlang.com/schema/project-settings",
+	sourceLanguageTag: "en",
+	languageTags: ["en"],
+	modules: [
+		// for instant gratification, we're adding common rules
+		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-empty-pattern@latest/dist/index.js",
+		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-missing-translation@latest/dist/index.js",
+		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-without-source@latest/dist/index.js",
+		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-valid-js-identifier@latest/dist/index.js",
+
+		// default to the message format plugin because it supports all features
+		"https://cdn.jsdelivr.net/npm/@inlang/plugin-message-format@latest/dist/index.js",
+
+		// the m function matcher should be installed by default in case Sherlock (VS Code extension) is adopted
+		"https://cdn.jsdelivr.net/npm/@inlang/plugin-m-function-matcher@latest/dist/index.js",
+	],
+	"plugin.inlang.messageFormat": {
+		pathPattern: "./messages/{languageTag}.json",
+	},
+} satisfies ProjectSettings

package/src/index.ts

@@ -12,6 +12,8 @@ export type {
 	Subscribable,
 } from "./api.js"
 export { type ImportFunction, createImport } from "./resolve-modules/index.js"
+export { createNewProject } from "./createNewProject.js"
+export { defaultProjectSettings } from "./defaultProjectSettings.js"
 export { loadProject } from "./loadProject.js"
 export { listProjects } from "./listProjects.js"
 export { solidAdapter, type InlangProjectWithSolidAdapter } from "./adapter/solidAdapter.js"

package/src/loadProject.test.ts

@@ -11,7 +11,6 @@ import type {
 import type { ImportFunction } from "./resolve-modules/index.js"
 import type { InlangModule } from "@inlang/module"
 import {
-	LoadProjectInvalidArgument,
 	ProjectSettingsFileJSONSyntaxError,
 	ProjectSettingsFileNotFoundError,
 	ProjectSettingsInvalidError,
@@ -175,7 +174,7 @@ it("should throw if a project (path) does not have a name", async () => {
 			_import,
 		})
 	)
-	expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument)
+	expect(project?.error?.message).toMatch('Expected a path ending in "{name}.inlang" but received ')
 })
 
 it("should throw if a project path does not end with .inlang", async () => {
@@ -195,7 +194,9 @@ it("should throw if a project path does not end with .inlang", async () => {
 				_import,
 			})
 		)
-		expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument)
+		expect(project.error?.message).toMatch(
+			'Expected a path ending in "{name}.inlang" but received '
+		)
 	}
 })
 
@@ -210,7 +211,7 @@ describe("initialization", () => {
 				_import,
 			})
 		)
-		expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument)
+		expect(result.error?.message).toBe('Expected an absolute path but received "relative/path".')
 		expect(result.data).toBeUndefined()
 	})
 

package/src/loadProject.ts

@@ -12,7 +12,6 @@ import {
 	ProjectSettingsFileNotFoundError,
 	ProjectSettingsInvalidError,
 	PluginSaveMessagesError,
-	LoadProjectInvalidArgument,
 	PluginLoadMessagesError,
 } from "./errors.js"
 import { createRoot, createSignal, createEffect } from "./reactivity/solid.js"
@@ -23,7 +22,7 @@ import { tryCatch, type Result } from "@inlang/result"
 import { migrateIfOutdated } from "@inlang/project-settings/migration"
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
 import { normalizePath, type NodeishFilesystem } from "@lix-js/fs"
-import { isAbsolutePath } from "./isAbsolutePath.js"
+import { assertValidProjectPath } from "./validateProjectPath.js"
 import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js"
 
 import { stringifyMessage as stringifyMessage } from "./storage/helper.js"
@@ -93,17 +92,7 @@ export async function loadProject(args: {
 	// 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" }
-		)
-	}
+	assertValidProjectPath(projectPath)
 
 	const nodeishFs = createNodeishFsWithAbsolutePaths({
 		projectPath,

package/src/migrations/maybeCreateFirstProjectId.test.ts

@@ -1,7 +1,6 @@
 import { generateProjectId } from "./maybeCreateFirstProjectId.js"
 import { it, expect } from "vitest"
-import { openRepository } from "@lix-js/client/src/openRepository.ts"
-import { mockRepo, createNodeishMemoryFs } from "@lix-js/client"
+import { mockRepo } from "@lix-js/client"
 import { type Snapshot } from "@lix-js/fs"
 // eslint-disable-next-line no-restricted-imports -- test
 import { readFileSync } from "node:fs"
@@ -22,13 +21,11 @@ it("should generate a project id", async () => {
 })
 
 it("should return undefined if repoMeta contains error", async () => {
-	const repoWithError = await openRepository("https://github.com/inlang/no-exist", {
-		nodeishFs: createNodeishMemoryFs(),
-	})
+	await repo.nodeishFs.rm("/.git", { recursive: true })
 
 	const projectId = await generateProjectId({
-		repo: repoWithError,
+		repo: repo,
 		projectPath: "mocked_project_path",
 	})
 	expect(projectId).toBeUndefined()
-})
+})

package/src/migrations/migrateToDirectory.ts

@@ -34,6 +34,9 @@ export const maybeMigrateToDirectory = async (args: {
 	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)
+
+	// eslint-disable-next-line no-console
+	// console.log("🔔 migrated project.inlang to directory")
 }
 
 const readme = `

package/src/validateProjectPath.test.ts

@@ -0,0 +1,68 @@
+import { assert, describe, expect, it } from "vitest"
+import {
+	assertValidProjectPath,
+	isAbsolutePath,
+	isInlangProjectPath,
+	pathExists,
+} from "./validateProjectPath.js"
+import { mockRepo } from "@lix-js/client"
+
+describe("isAbsolutePath", () => {
+	it("should correctly identify Unix absolute paths", () => {
+		assert.isTrue(isAbsolutePath("/home/user/documents/file.txt"))
+		assert.isTrue(isAbsolutePath("/usr/local/bin/script.sh"))
+		assert.isFalse(isAbsolutePath("relative/path/to/file.txt"))
+	})
+
+	it("should correctly identify Windows absolute paths", () => {
+		assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"))
+		assert.isTrue(isAbsolutePath("C:/Users/user/project.inlang/settings.json"))
+		assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"))
+	})
+
+	it("should handle edge cases", () => {
+		assert.isFalse(isAbsolutePath("")) // Empty path should return false
+		assert.isFalse(isAbsolutePath("relative/path/../file.txt")) // Relative path with ".." should return false
+		assert.isFalse(isAbsolutePath("../relative/path/to/file.txt"))
+		assert.isFalse(isAbsolutePath("./relative/path/to/file.txt"))
+	})
+})
+
+describe("isInlangProjectPath", () => {
+	it("should correctly identify valid inlang project paths", () => {
+		assert.isTrue(isInlangProjectPath("/path/to/orange-mouse.inlang"))
+		assert.isFalse(isInlangProjectPath("relative/path/to/file.txt"))
+		assert.isFalse(isInlangProjectPath("/path/to/.inlang"))
+		assert.isFalse(isInlangProjectPath("/path/to/white-elephant.inlang/"))
+		assert.isFalse(isInlangProjectPath("/path/to/blue-elephant.inlang/settings.json"))
+	})
+})
+
+describe("assertValidProjectPath", () => {
+	it("should not throw for valid project paths", () => {
+		assert.doesNotThrow(() => assertValidProjectPath("/path/to/brown-mouse.inlang"))
+		assert.doesNotThrow(() => assertValidProjectPath("/path/to/green-elephant.inlang"))
+	})
+
+	it("should throw for invalid project paths", () => {
+		assert.throws(() => assertValidProjectPath("relative/path/to/flying-lizard.inlang"))
+		assert.throws(() => assertValidProjectPath("/path/to/loud-mouse.inlang/"))
+		assert.throws(() => assertValidProjectPath("/path/to/green-elephant.inlang/settings.json"))
+	})
+})
+
+// moar tests in paraglide-js/src/services/file-handling/exists.test.ts
+describe("pathExists", () => {
+	it("should work for files", async () => {
+		const repo = await mockRepo()
+		await repo.nodeishFs.writeFile("/test.txt", "hello")
+		expect(await pathExists("/test.txt", repo.nodeishFs)).toBe(true)
+		expect(await pathExists("/does-not-exist.txt", repo.nodeishFs)).toBe(false)
+	})
+	it("should work for directories", async () => {
+		const repo = await mockRepo()
+		await repo.nodeishFs.mkdir("/test/project.inlang", { recursive: true })
+		expect(await pathExists("/test/project.inlang", repo.nodeishFs)).toBe(true)
+		expect(await pathExists("/test/white-gorilla.inlang", repo.nodeishFs)).toBe(false)
+	})
+})

package/src/validateProjectPath.ts

@@ -0,0 +1,58 @@
+import type { NodeishFilesystem } from "@lix-js/fs"
+
+/**
+ * validate that a project path is absolute and ends with {name}.inlang.
+ *
+ * @throws if the path is not valid.
+ */
+export function assertValidProjectPath(projectPath: string) {
+	if (!isAbsolutePath(projectPath)) {
+		throw new Error(`Expected an absolute path but received "${projectPath}".`)
+	}
+	if (!isInlangProjectPath(projectPath)) {
+		throw new Error(
+			`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`
+		)
+	}
+}
+
+/**
+ * tests whether a path ends with {name}.inlang
+ * (does not remove trailing slash)
+ */
+export function isInlangProjectPath(path: string) {
+	return /[^\\/]+\.inlang$/.test(path)
+}
+
+/**
+ * tests whether a path starts with a forward slash (/) or a windows-style
+ * drive letter (C: or D:, etc.) followed by a slash
+ */
+export function isAbsolutePath(path: string) {
+	return /^\/|^[A-Za-z]:[\\/]/.test(path)
+
+	// OG from sdk/src/isAbsolutePath.ts - TODO: find out where this regex came from
+	// const matchPosixAndWindowsAbsolutePaths =
+	// 	/^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/
+	// return matchPosixAndWindowsAbsolutePaths.test(path)
+}
+
+/**
+ * Returns true if the path exists (file or directory), false otherwise.
+ *
+ */
+export async function pathExists(filePath: string, nodeishFs: NodeishFilesystem) {
+	// from paraglide-js/src/services/file-handling/exists.ts
+	// TODO: add fs.exists to @lix-js/fs
+	try {
+		await nodeishFs.stat(filePath)
+		return true
+	} catch (error) {
+		//@ts-ignore
+		if (error.code === "ENOENT") {
+			return false
+		} else {
+			throw new Error(`Failed to check if path exists: ${error}`, { cause: error })
+		}
+	}
+}

package/dist/isAbsolutePath.d.ts

@@ -1,2 +0,0 @@
-export declare const isAbsolutePath: (path: string) => boolean;
-//# sourceMappingURL=isAbsolutePath.d.ts.map

package/dist/isAbsolutePath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isAbsolutePath.d.ts","sourceRoot":"","sources":["../src/isAbsolutePath.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,SAAU,MAAM,YAI1C,CAAA"}

package/dist/isAbsolutePath.js

@@ -1,4 +0,0 @@
-export const isAbsolutePath = (path) => {
-    const matchPosixAndWindowsAbsolutePaths = /^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/;
-    return matchPosixAndWindowsAbsolutePaths.test(path);
-};

package/dist/isAbsolutePath.test.d.ts

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

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

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

package/dist/isAbsolutePath.test.js

@@ -1,20 +0,0 @@
-import { assert, describe, it } from "vitest";
-import { isAbsolutePath } from "./isAbsolutePath.js";
-describe("isAbsolutePath", () => {
-    it("should correctly identify Unix absolute paths", () => {
-        assert.isTrue(isAbsolutePath("/home/user/documents/file.txt"));
-        assert.isTrue(isAbsolutePath("/usr/local/bin/script.sh"));
-        assert.isFalse(isAbsolutePath("relative/path/to/file.txt"));
-    });
-    it("should correctly identify Windows absolute paths", () => {
-        assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"));
-        assert.isTrue(isAbsolutePath("C:/Users/user/project.inlang/settings.json"));
-        assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"));
-    });
-    it("should handle edge cases", () => {
-        assert.isFalse(isAbsolutePath("")); // Empty path should return false
-        assert.isFalse(isAbsolutePath("relative/path/../file.txt")); // Relative path with ".." should return false
-        assert.isFalse(isAbsolutePath("../relative/path/to/file.txt"));
-        assert.isFalse(isAbsolutePath("./relative/path/to/file.txt"));
-    });
-});

package/src/isAbsolutePath.test.ts

@@ -1,23 +0,0 @@
-import { assert, describe, it } from "vitest"
-import { isAbsolutePath } from "./isAbsolutePath.js"
-
-describe("isAbsolutePath", () => {
-	it("should correctly identify Unix absolute paths", () => {
-		assert.isTrue(isAbsolutePath("/home/user/documents/file.txt"))
-		assert.isTrue(isAbsolutePath("/usr/local/bin/script.sh"))
-		assert.isFalse(isAbsolutePath("relative/path/to/file.txt"))
-	})
-
-	it("should correctly identify Windows absolute paths", () => {
-		assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"))
-		assert.isTrue(isAbsolutePath("C:/Users/user/project.inlang/settings.json"))
-		assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"))
-	})
-
-	it("should handle edge cases", () => {
-		assert.isFalse(isAbsolutePath("")) // Empty path should return false
-		assert.isFalse(isAbsolutePath("relative/path/../file.txt")) // Relative path with ".." should return false
-		assert.isFalse(isAbsolutePath("../relative/path/to/file.txt"))
-		assert.isFalse(isAbsolutePath("./relative/path/to/file.txt"))
-	})
-})

package/src/isAbsolutePath.ts

@@ -1,5 +0,0 @@
-export const isAbsolutePath = (path: string) => {
-	const matchPosixAndWindowsAbsolutePaths =
-		/^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/
-	return matchPosixAndWindowsAbsolutePaths.test(path)
-}