@inlang/paraglide-js 1.0.0-prerelease.2 → 1.0.0-prerelease.4

package/dist/cli/commands/init.test.js

@@ -0,0 +1,472 @@
+import { test, expect, vi, beforeAll, beforeEach } from "vitest";
+import { addCompileStepToPackageJSON, addParaglideJsToDependencies, adjustTsConfigIfNecessary, checkIfPackageJsonExists, checkIfUncommittedChanges, createNewProjectFlow, existingProjectFlow, findExistingInlangProjectPath, initializeInlangProject, newProjectTemplate, promptForNamespace, } from "./init.js";
+import consola from "consola";
+import { describe } from "node:test";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import childProcess from "node:child_process";
+import memfs from "memfs";
+import { version } from "../state.js";
+beforeAll(() => {
+    // spy on commonly used functions to prevent console output
+    // and allow expecations
+    vi.spyOn(consola, "log").mockImplementation(() => undefined);
+    vi.spyOn(consola, "info").mockImplementation(() => undefined);
+    vi.spyOn(consola, "success").mockImplementation(() => undefined);
+    vi.spyOn(consola, "error").mockImplementation(() => undefined);
+    vi.spyOn(consola, "warn").mockImplementation(() => undefined);
+});
+beforeEach(() => {
+    vi.resetAllMocks();
+    // Re-mock consola before each test call to remove calls from before
+    consola.mockTypes(() => vi.fn());
+    // set the current working directory to some mock value to prevent
+    // the tests from failing when running in a different environment
+    process.cwd = () => "/";
+});
+describe("end to end tests", () => {
+    test("it should exit if the user presses CTRL+C", async () => {
+        mockFiles({});
+        mockUserInput([
+            // the first user input is CTRL+C
+            () => process.emit("SIGINT", "SIGINT"),
+        ]);
+        // simulating a throw to exit the command early without
+        // killing the process the test runs in
+        vi.spyOn(process, "exit").mockImplementation(() => {
+            throw "process.exit";
+        });
+        try {
+            await checkIfPackageJsonExists();
+        }
+        catch (e) {
+            expect(e).toBe("process.exit");
+        }
+        expect(process.exit).toHaveBeenCalledOnce();
+    });
+});
+describe("initializeInlangProject()", () => {
+    test("it should execute existingProjectFlow() if a project has been found", async () => {
+        mockFiles({
+            "/folder/project.inlang.json": JSON.stringify(newProjectTemplate),
+            "/folder/subfolder": {},
+        });
+        process.cwd = () => "/folder/subfolder";
+        mockUserInput(["useExistingProject"]);
+        const path = await initializeInlangProject();
+        expect(path).toBe("../project.inlang.json");
+    }, {
+        // i am on a plane with bad internet
+        timeout: 20000,
+    });
+    test("it should execute newProjectFlow() if not project has been found", async () => {
+        const { existsSync } = mockFiles({});
+        mockUserInput(["newProject"]);
+        const path = await initializeInlangProject();
+        expect(path).toBe("./project.inlang.json");
+        expect(existsSync("./project.inlang.json")).toBe(true);
+    });
+});
+describe("addParaglideJsToDependencies()", () => {
+    test("it should add paraglide-js to the dependencies with the latest version", async () => {
+        mockFiles({
+            "/package.json": "{}",
+        });
+        await addParaglideJsToDependencies();
+        expect(fs.writeFile).toHaveBeenCalledOnce();
+        expect(consola.success).toHaveBeenCalledOnce();
+        const packageJson = JSON.parse((await fs.readFile("/package.json", { encoding: "utf-8" })));
+        expect(packageJson.dependencies["@inlang/paraglide-js"]).toBe(version);
+    });
+});
+describe("addCompileStepToPackageJSON()", () => {
+    test("if no scripts exist, it should add scripts.build", async () => {
+        mockFiles({
+            "/package.json": "{}",
+        });
+        await addCompileStepToPackageJSON({
+            projectPath: "./project.inlang.json",
+            namespace: "frontend",
+        });
+        expect(fs.writeFile).toHaveBeenCalledOnce();
+        expect(consola.success).toHaveBeenCalledOnce();
+        const packageJson = JSON.parse((await fs.readFile("/package.json", { encoding: "utf-8" })));
+        expect(packageJson.scripts.build).toBe(`paraglide-js compile --project ./project.inlang.json --namespace frontend`);
+    });
+    test("if an existing build step exists, it should be preceeded by the paraglide-js compile command", async () => {
+        mockFiles({
+            "/package.json": JSON.stringify({
+                scripts: {
+                    build: "some build step",
+                },
+            }),
+        });
+        await addCompileStepToPackageJSON({
+            projectPath: "./project.inlang.json",
+            namespace: "frontend",
+        });
+        expect(fs.writeFile).toHaveBeenCalledOnce();
+        expect(consola.success).toHaveBeenCalledOnce();
+        const packageJson = JSON.parse((await fs.readFile("/package.json", { encoding: "utf-8" })));
+        expect(packageJson.scripts.build).toBe(`paraglide-js compile --project ./project.inlang.json --namespace frontend && some build step`);
+    });
+    test("if a paraglide-js compile step already exists, the user should be prompted to update it manually and exit if the user rejects", async () => {
+        mockFiles({
+            "/package.json": JSON.stringify({
+                scripts: {
+                    build: "paraglide-js compile --project ./project.inlang.json",
+                },
+            }),
+        });
+        mockUserInput([
+            // user does not want to update the build step
+            false,
+        ]);
+        await addCompileStepToPackageJSON({
+            projectPath: "./project.inlang.json",
+            namespace: "frontend",
+        });
+        expect(fs.writeFile).not.toHaveBeenCalled();
+        expect(consola.success).not.toHaveBeenCalled();
+        expect(consola.warn).toHaveBeenCalledOnce();
+        expect(process.exit).toHaveBeenCalled();
+    });
+    test("if a paraglide-js compile step already exists, the user should be prompted to update it manually and return if they did so", async () => {
+        mockFiles({
+            "/package.json": JSON.stringify({
+                scripts: {
+                    build: "paraglide-js compile --project ./project.inlang.json",
+                },
+            }),
+        });
+        mockUserInput([
+            // user does not want to update the build step
+            true,
+        ]);
+        await addCompileStepToPackageJSON({
+            projectPath: "./project.inlang.json",
+            namespace: "frontend",
+        });
+        expect(fs.writeFile).not.toHaveBeenCalled();
+        expect(consola.success).not.toHaveBeenCalled();
+        expect(consola.warn).toHaveBeenCalledOnce();
+        expect(process.exit).not.toHaveBeenCalled();
+    });
+});
+describe("promptForNamespace()", async () => {
+    test("it should trim the input from whitespace", async () => {
+        mockUserInput(["  frontend  "]);
+        const namespace = await promptForNamespace();
+        expect(namespace).toBe("frontend");
+    });
+});
+describe("existingProjectFlow()", () => {
+    test("if the user selects to proceed with the existing project and the project has no errors, the function should return", async () => {
+        mockFiles({
+            "/project.inlang.json": JSON.stringify(newProjectTemplate),
+        });
+        mockUserInput(["useExistingProject"]);
+        expect(existingProjectFlow({ existingProjectPath: "/project.inlang.json" })).resolves.toBeUndefined();
+    });
+    test("if the user selects new project, the newProjectFlow() should be executed", async () => {
+        const { existsSync } = mockFiles({
+            "/folder/project.inlang.json": JSON.stringify(newProjectTemplate),
+        });
+        mockUserInput(["newProject"]);
+        await existingProjectFlow({ existingProjectPath: "/folder/project.inlang.json" });
+        // info that a new project is created
+        expect(consola.info).toHaveBeenCalledOnce();
+        // the newly created project file should exist
+        expect(existsSync("/project.inlang.json")).toBe(true);
+    });
+    test("it should exit if the existing project contains errors", async () => {
+        mockFiles({
+            "/project.inlang.json": `BROKEN PROJECT FILE`,
+        });
+        mockUserInput(["useExistingProject"]);
+        await existingProjectFlow({ existingProjectPath: "/project.inlang.json" });
+        expect(consola.error).toHaveBeenCalled();
+        expect(process.exit).toHaveBeenCalled();
+    });
+});
+describe("createNewProjectFlow()", async () => {
+    test("it should succeed in creating a new project", async () => {
+        const { existsSync } = mockFiles({});
+        await createNewProjectFlow();
+        // user is informed that a new project is created
+        expect(consola.info).toHaveBeenCalledOnce();
+        // the project shouldn't have errors
+        expect(consola.error).not.toHaveBeenCalled();
+        // user is informed that the project has successfully been created
+        expect(consola.success).toHaveBeenCalledOnce();
+        // the project file should exist
+        expect(existsSync("/project.inlang.json")).toBe(true);
+    }, {
+        // i am testing this while i am on an airplane with slow internet
+        timeout: 20000,
+    });
+    test("it should exit if the project has errors", async () => {
+        mockFiles({});
+        // invalid project settings file
+        vi.spyOn(JSON, "stringify").mockReturnValue(`{}`);
+        await createNewProjectFlow();
+        // user is informed that a new project is created
+        expect(consola.info).toHaveBeenCalledOnce();
+        // the project has errors
+        expect(consola.error).toHaveBeenCalled();
+        // the commands exits
+        expect(process.exit).toHaveBeenCalled();
+    });
+});
+describe("checkIfUncommittedChanges()", () => {
+    test("it should not fail if the git cli is not installed", async () => {
+        vi.spyOn(childProcess, "execSync").mockImplementation(() => {
+            throw Error("Command failed: git status");
+        });
+        expect(checkIfUncommittedChanges()).resolves.toBeUndefined();
+    });
+    test("it should continue if no uncomitted changes exist", async () => {
+        vi.spyOn(childProcess, "execSync").mockImplementation(() => {
+            return Buffer.from("");
+        });
+        expect(checkIfUncommittedChanges()).resolves.toBeUndefined();
+    });
+    test("it should prompt the user if there are uncommitted changes and exit if the user doesn't want to continue", async () => {
+        vi.spyOn(childProcess, "execSync").mockImplementation(() => {
+            return Buffer.from("M package.json");
+        });
+        const processExit = vi.spyOn(process, "exit").mockImplementation(() => undefined);
+        mockUserInput([
+            // user does not want to continue
+            false,
+        ]);
+        await checkIfUncommittedChanges();
+        expect(consola.info).toHaveBeenCalledOnce();
+        expect(consola.prompt).toHaveBeenCalledOnce();
+        expect(processExit).toHaveBeenCalledOnce();
+    });
+    test("it should prompt the user if there are uncommitted changes and return if the user wants to continue", async () => {
+        vi.spyOn(childProcess, "execSync").mockImplementation(() => {
+            return Buffer.from("M package.json");
+        });
+        const processExit = vi.spyOn(process, "exit").mockImplementation(() => undefined);
+        mockUserInput([
+            // user does want to continue
+            true,
+        ]);
+        await checkIfUncommittedChanges();
+        expect(consola.info).toHaveBeenCalledOnce();
+        expect(consola.prompt).toHaveBeenCalledOnce();
+        expect(processExit).not.toHaveBeenCalledOnce();
+    });
+    test("it should not prompt the user if no uncommitted changes exist", async () => {
+        await checkIfUncommittedChanges();
+        expect(consola.prompt).not.toHaveBeenCalled();
+    });
+});
+describe("checkIfPackageJsonExists()", () => {
+    test("it should exit if no package.json has been found", async () => {
+        mockFiles({});
+        await checkIfPackageJsonExists();
+        expect(consola.warn).toHaveBeenCalledOnce();
+        expect(process.exit).toHaveBeenCalledOnce();
+    });
+    test("it should not exit if a package.json exists in the current working directory", async () => {
+        mockFiles({ "package.json": "" });
+        await checkIfPackageJsonExists();
+        expect(consola.warn).not.toHaveBeenCalled();
+        expect(process.exit).not.toHaveBeenCalled();
+    });
+});
+describe("findExistingInlangProjectPath()", () => {
+    test("it should return undefined if no project.inlang.json has been found", async () => {
+        mockFiles({});
+        const path = await findExistingInlangProjectPath();
+        expect(path).toBeUndefined();
+    });
+    test("it find a project in the current working directory", async () => {
+        process.cwd = () => "/";
+        mockFiles({ "project.inlang.json": "{}" });
+        const path = await findExistingInlangProjectPath();
+        expect(path).toBe("./project.inlang.json");
+    });
+    test("it should find a project in a parent directory", async () => {
+        process.cwd = () => "/nested/";
+        mockFiles({
+            "/project.inlang.json": "{}",
+            "/nested/": {},
+        });
+        const path = await findExistingInlangProjectPath();
+        expect(path).toBe("../project.inlang.json");
+    });
+    test("it should find a project in a parent parent directory", async () => {
+        process.cwd = () => "/nested/nested/";
+        mockFiles({
+            "/project.inlang.json": "{}",
+            "/nested/nested/": {},
+        });
+        const path = await findExistingInlangProjectPath();
+        expect(path).toBe("../../project.inlang.json");
+    });
+});
+describe("adjustTsConfigIfNecessary()", () => {
+    test("it should return if no tsconfig.json exists", async () => {
+        mockFiles({});
+        const result = await adjustTsConfigIfNecessary();
+        // no tsconfig exists, immediately return
+        expect(result).toBeUndefined();
+        // the tsconfig should not have been read
+        expect(fs.readFile).not.toHaveBeenCalled();
+        // no info that the moduleResolution needs to be adapted should be logged
+        expect(consola.info).not.toHaveBeenCalled();
+    });
+    test("it should warn if the extended from tsconfig can't be read", async () => {
+        mockFiles({
+            "/tsconfig.json": `{ 
+				"extends": "./non-existend.json",
+				"compilerOptions": {
+					"moduleResolution": "Bundler"
+				} 
+			}`,
+        });
+        await adjustTsConfigIfNecessary();
+        // no info that the moduleResolution needs to be adapted should be logged
+        expect(consola.warn).toHaveBeenCalledOnce();
+    });
+    test("it should detect if the extended from tsconfig already set the moduleResolution to bundler", async () => {
+        mockFiles({
+            "/tsconfig.base.json": `{
+				"compilerOptions": {
+					"moduleResolution": "Bundler"
+				}
+			}`,
+            "/tsconfig.json": `{ 
+				"extends": "tsconfig.base.json", 
+			}`,
+        });
+        await adjustTsConfigIfNecessary();
+        // no info that the moduleResolution needs to be adapted should be logged
+        expect(consola.info).not.toHaveBeenCalled();
+    });
+    test("it should prompt the user to set the moduleResolution to bundler", async () => {
+        mockFiles({
+            "/tsconfig.json": `{}`,
+        });
+        const userAdjustsTsConfigSpy = vi.fn();
+        mockUserInput([
+            // user confirms that the moduleResolution has been set to bundler
+            () => {
+                userAdjustsTsConfigSpy();
+                fs.writeFile("/tsconfig.json", `{
+						"compilerOptions": {
+							"moduleResolution": "Bundler"
+						}
+					}`);
+                return true;
+            },
+        ]);
+        await adjustTsConfigIfNecessary();
+        // info that the moduleResolution needs to be adapted
+        expect(consola.info).toHaveBeenCalledOnce();
+        // prompt the user to set the moduleResolution to bundler
+        expect(consola.prompt).toHaveBeenCalledOnce();
+        // user has set the moduleResolution to bundler
+        expect(userAdjustsTsConfigSpy).toHaveBeenCalledOnce();
+    });
+    test("it should keep prompting the user to set the moduleResolution to bundler if the moduleResolution has not been set", async () => {
+        mockFiles({
+            "/tsconfig.json": `{}`,
+        });
+        mockUserInput([
+            // user confirms that the moduleResolution has been set to bundler
+            // while the moduleResolution is still not set
+            // -> should prompt again
+            true,
+            // user wants to exit
+            // -> should warn that type errors might occur and continue with init
+            false,
+        ]);
+        await adjustTsConfigIfNecessary();
+        // info that the moduleResolution needs to be adapted
+        expect(consola.warn).toHaveBeenCalledOnce();
+        // 1. prompt the user to set the moduleResolution to bundler
+        // 2. prompt again because the moduleResolution is still not set
+        expect(consola.prompt).toHaveBeenCalledTimes(2);
+        // the user has not set the moduleResolution to bundler
+        // after the first prompt eventhough the user said it did
+        expect(consola.error).toHaveBeenCalledOnce();
+        // the user exists without setting the moduleResolution to bundler
+        // warn about type errors
+        expect(consola.warn).toHaveBeenCalledOnce();
+    });
+});
+// test("the paraglide plugin for vscode should be installed", () => {
+// 	throw new Error("Not implemented")
+// })
+// test("it sets the tsconfig compiler option 'moduleResolution' to 'bundler'", () => {
+// 	throw new Error("Not implemented")
+// })
+// test("it should create a project if it doesn't exist", () => {
+// 	test("the inlang message format should be the default selection", () => {
+// 		throw new Error("Not implemented")
+// 	})
+// })
+// test("the vscode extension should be added to the workspace recommendations", () => {
+// 	test("automatically if the .vscode folder exists", () => {
+// 		throw new Error("Not implemented")
+// 	})
+// 	test("else, the user should be prompted if the vscode extension should be added", () => {
+// 		throw new Error("Not implemented")
+// 	})
+// })
+// describe("it should prompt the user if the cli should be added for linting and machine translations", () => {
+// 	test("the cli should be added to the devDependencies", () => {
+// 		throw new Error("Not implemented")
+// 	})
+// 	test("if a lint script exists, inlang lint should be added to the lint script", () => {
+// 		throw new Error("Not implemented")
+// 	})
+// 	test("if no lint script exists, the lint script should be created in the package.json", () => {
+// 		throw new Error("Not implemented")
+// 	})
+// })
+// test("the user should be prompted for the framework and forwarded to the corresponding guide", () => {
+// 	throw new Error("Not implemented")
+// })
+/**
+ * Mock user input.
+ *
+ * @example
+ * 	 mockUserInput([
+ * 		"some input",
+ * 		() => {
+ *      fs.writeFileSync("some-file", "some content")
+ *      return true
+ *    }
+ * 	 ]),
+ */
+const mockUserInput = (testUserInput) => {
+    vi.spyOn(consola, "prompt").mockImplementation(() => {
+        const value = testUserInput.shift();
+        if (value === undefined) {
+            throw new Error("End of test input");
+        }
+        else if (typeof value === "function") {
+            return value();
+        }
+        return value;
+    });
+};
+const mockFiles = (files) => {
+    const _memfs = memfs.createFsFromVolume(memfs.Volume.fromNestedJSON(files));
+    vi.spyOn(fsSync, "existsSync").mockImplementation(_memfs.existsSync);
+    for (const prop in fs) {
+        // @ts-ignore - memfs has the same interface as node:fs/promises
+        if (typeof fs[prop] !== "function")
+            continue;
+        // @ts-ignore - memfs has the same interface as node:fs/promises
+        vi.spyOn(fs, prop).mockImplementation(_memfs.promises[prop]);
+    }
+    return { existsSync: _memfs.existsSync };
+};
+test("a tsconfig with comments should be loaded correctly", () => { });

package/dist/cli/main.d.ts

@@ -1,11 +1,3 @@
 import { Command } from "commander";
-/**
- * The absolute path to the paraglide directory.
- *
- * slices a path
- * from '/Users/samuel/example/repository/node_modules/paraglide-js/dist/cli/main.js'
- * to   '/Users/samuel/example/repository/node_modules/paraglide-js'
- */
-export declare const paraglideDirectory: string;
 export declare const cli: Command;
 //# sourceMappingURL=main.d.ts.map

package/dist/cli/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAUnC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAA4D,CAAA;AAE7F,eAAO,MAAM,GAAG,SAqBb,CAAA"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAKnC,eAAO,MAAM,GAAG,SA0Bb,CAAA"}

package/dist/cli/main.js

@@ -1,40 +1,31 @@
 import consola from "consola";
 import dedent from "dedent";
-import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 import { compileCommand } from "./commands/compile.js";
-/**
- * The path this file is executed from.
- *
- * Usually something like '/Users/samuel/example/repository/node_modules/paraglide-js/dist/cli/main.js'
- */
-const metaUrlPath = fileURLToPath(import.meta.url);
-/**
- * The absolute path to the paraglide directory.
- *
- * slices a path
- * from '/Users/samuel/example/repository/node_modules/paraglide-js/dist/cli/main.js'
- * to   '/Users/samuel/example/repository/node_modules/paraglide-js'
- */
-export const paraglideDirectory = metaUrlPath.slice(0, metaUrlPath.indexOf("/dist/"));
+import { paraglideDirectory, version } from "./state.js";
+import { initCommand } from "./commands/init.js";
 export const cli = new Command()
     .name("paraglide-js")
     .addCommand(compileCommand)
-    .hook("preAction", () => {
+    .addCommand(initCommand)
+    .showHelpAfterError()
+    .version(version)
+    .action(() => {
     // ------------------- VALIDATE IF RUNNING FROM CORRECT FOLDER -------------------
     // the CLI expects to be running from the dist folder of the specific paraglide package
     // to compile the output in the correct directory
-    if (metaUrlPath.includes(`paraglide-js/dist/`) === false) {
+    if (paraglideDirectory.endsWith(`paraglide-js`) === false) {
         consola.error(dedent `
-			The CLI is not running from the dist folder. 
+			The CLI is not running from a paraglide-js directory. 
 
 			This is likely an internal bug. Please file an issue at https://github.com/inlang/monorepo/issues.
 
 			Debug information: 
 
-			- metaUrlPath: ${metaUrlPath}
+			- paraglideDirectory: ${paraglideDirectory}
 			`);
-        process.exit(1);
+        return process.exit(1);
     }
+    // show the help because no command is specified
+    return cli.help();
 });
-cli.showHelpAfterError(true);

package/dist/cli/main.test.d.ts

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

package/dist/cli/main.test.d.ts.map

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

package/dist/cli/main.test.js

@@ -0,0 +1,37 @@
+import { describe, test, expect, vi } from "vitest";
+import { _setStateForTest } from "./state.js";
+import { cli } from "./main.js";
+import consola from "consola";
+// surpress output for clean test output
+cli.configureOutput({ writeErr: () => { }, writeOut: () => { } });
+describe("it should exit if the CLI is not running from the dist folder", () => {
+    const shouldSucceed = [
+        "/Users/example/repository/node_modules/paraglide-js",
+        "/node_modules/paraglide-js",
+        // windows... https://github.com/inlang/monorepo/issues/1478
+        "C:\\Users\\Projects\\svelte-one\\node_modules\\@inlang\\paraglide-js",
+    ];
+    const shouldFail = ["/Users/samuel/example/repository"];
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => undefined);
+    // remove error message to have clean test output
+    vi.spyOn(consola, "error").mockImplementation(() => undefined);
+    for (const path of shouldSucceed) {
+        test("suceed with " + path, async () => {
+            // surpress output to have clean test output
+            _setStateForTest({
+                paraglideDirectory: path,
+            });
+            await cli.parseAsync([]);
+            expect(exitSpy).toHaveBeenLastCalledWith(0);
+        });
+    }
+    for (const path of shouldFail) {
+        test("fail with " + path, async () => {
+            _setStateForTest({
+                paraglideDirectory: path,
+            });
+            await cli.parseAsync([]);
+            expect(exitSpy).toHaveBeenLastCalledWith(1);
+        });
+    }
+});

package/dist/cli/state.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The absolute path to the paraglide directory.
+ *
+ * slices a path
+ * from '/Users/samuel/example/repository/node_modules/paraglide-js/dist/cli/main.js'
+ * to   '/Users/samuel/example/repository/node_modules/paraglide-js'
+ */
+export declare let paraglideDirectory: string;
+export declare const _setStateForTest: (values: Record<"paraglideDirectory", any>) => void;
+/**
+ * The version of the paraglide-js package.
+ */
+export declare const version: any;
+//# sourceMappingURL=state.d.ts.map

package/dist/cli/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/cli/state.ts"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,eAAO,IAAI,kBAAkB,EAAE,MAG9B,CAAA;AAID,eAAO,MAAM,gBAAgB,WAAY,OAAO,oBAAoB,EAAE,GAAG,CAAC,SAEzE,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,OAAO,KAEX,CAAA"}

package/dist/cli/state.js

@@ -0,0 +1,28 @@
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+/**
+ * The posix path this file is executed from.
+ *
+ * Usually something like '/Users/samuel/example/repository/node_modules/paraglide-js/dist/cli/main.js'
+ */
+const currentFilePath = fileURLToPath(import.meta.url)
+    .split(path.sep)
+    .join(path.posix.sep);
+/**
+ * The absolute path to the paraglide directory.
+ *
+ * slices a path
+ * from '/Users/samuel/example/repository/node_modules/paraglide-js/dist/cli/main.js'
+ * to   '/Users/samuel/example/repository/node_modules/paraglide-js'
+ */
+export let paraglideDirectory = currentFilePath.slice(0, currentFilePath.indexOf("/paraglide-js/") + "/paraglide-js".length);
+// this is only used for testing
+// use cmd + f to find all usages
+export const _setStateForTest = (values) => {
+    paraglideDirectory = values.paraglideDirectory;
+};
+/**
+ * The version of the paraglide-js package.
+ */
+export const version = JSON.parse(fs.readFileSync(`${paraglideDirectory}/package.json`, "utf-8")).version;