@inlang/paraglide-js 1.2.0 → 1.2.1

package/dist/cli/commands/init.d.ts

@@ -1,31 +1,39 @@
 import { Command } from "commander";
 import { type ProjectSettings } from "@inlang/sdk";
 import { Logger } from "../../services/logger/index.js";
+import { type Repository } from "@lix-js/client";
+import type { NodeishFilesystem } from "@lix-js/fs";
+type Context = {
+    logger: Logger;
+    repo: Repository;
+};
 export declare const initCommand: Command;
-export declare const initializeInlangProject: (logger: Logger) => Promise<string>;
+export declare const initializeInlangProject: (ctx: Context) => Promise<string>;
 export declare const maybeAddVsCodeExtension: (args: {
     projectPath: string;
-}, logger: Logger) => Promise<void>;
-export declare const addParaglideJsToDevDependencies: (logger: Logger) => Promise<void>;
-export declare const findExistingInlangProjectPath: () => Promise<string | undefined>;
+}, ctx: Context) => Promise<void>;
+export declare const addParaglideJsToDevDependencies: (ctx: Context) => Promise<void>;
+export declare const findExistingInlangProjectPath: (ctx: Context) => Promise<string | undefined>;
 export declare const existingProjectFlow: (args: {
     existingProjectPath: string;
-}, logger: Logger) => Promise<undefined>;
-export declare const createNewProjectFlow: (logger: Logger) => Promise<undefined>;
+}, ctx: Context) => Promise<undefined>;
+export declare const createNewProjectFlow: (ctx: Context) => Promise<undefined>;
 export declare const newProjectTemplate: ProjectSettings;
-export declare const checkIfPackageJsonExists: (logger: Logger) => Promise<undefined>;
-export declare const checkIfUncommittedChanges: (logger: Logger) => Promise<void>;
+export declare const checkIfPackageJsonExists: (ctx: Context) => Promise<undefined>;
+export declare const checkIfUncommittedChanges: (ctx: Context) => Promise<void>;
 export declare const addCompileStepToPackageJSON: (args: {
     projectPath: string;
-}, logger: Logger) => Promise<undefined>;
+}, ctx: Context) => Promise<undefined>;
 /**
  * Ensures that the moduleResolution compiler option is set to "bundler" or similar in the tsconfig.json.
  *
  * Otherwise, types defined in `package.exports` are not resolved by TypeScript. Leading to type
  * errors with Paraglide-JS.
  */
-export declare const maybeChangeTsConfigModuleResolution: (logger: Logger) => Promise<void>;
+export declare const maybeChangeTsConfigModuleResolution: (ctx: Context) => Promise<void>;
 /**
  * Paraligde JS compiles to JS with JSDoc comments. TypeScript doesn't allow JS files by default.
  */
-export declare const maybeChangeTsConfigAllowJs: (logger: Logger) => Promise<void>;
+export declare const maybeChangeTsConfigAllowJs: (ctx: Context) => Promise<void>;
+export declare function fileExists(filePath: string, nodeishFs: NodeishFilesystem): Promise<boolean>;
+export {};

package/dist/index.js

@@ -20428,7 +20428,7 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "../../../../node_modules/.pnpm/dotenv@16.3.1/node_modules/dotenv/lib/main.js"(exports, module) {
     init_define_ENV_DEFINED_IN_BUILD_STEP();
-    var fs4 = __require("fs");
+    var fs2 = __require("fs");
     var path3 = __require("path");
     var os = __require("os");
     var crypto3 = __require("crypto");
@@ -20553,7 +20553,7 @@ var require_main = __commonJS({
         }
       }
       try {
-        const parsed = DotenvModule.parse(fs4.readFileSync(dotenvPath, { encoding }));
+        const parsed = DotenvModule.parse(fs2.readFileSync(dotenvPath, { encoding }));
         let processEnv = process.env;
         if (options && options.processEnv != null) {
           processEnv = options.processEnv;
@@ -20572,7 +20572,7 @@ var require_main = __commonJS({
       if (_dotenvKey(options).length === 0) {
         return DotenvModule.configDotenv(options);
       }
-      if (!fs4.existsSync(vaultPath)) {
+      if (!fs2.existsSync(vaultPath)) {
         _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
         return DotenvModule.configDotenv(options);
       }
@@ -23847,7 +23847,7 @@ var createEffect4 = createEffect3;
 // ../../../../lix/source-code/client/dist/git/commit.js
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 import { walk, TREE, STAGE, writeTree, commit as doCommit } from "isomorphic-git";
-async function commit({ fs: fs4, dir, ref, author, message }) {
+async function commit({ fs: fs2, dir, ref, author, message }) {
   const fileStates = {};
   async function createTree(currentFolder, fileStates2) {
     const entries = [];
@@ -23875,10 +23875,10 @@ async function commit({ fs: fs4, dir, ref, author, message }) {
         });
       }
     }
-    return await writeTree({ fs: fs4, dir, tree: entries });
+    return await writeTree({ fs: fs2, dir, tree: entries });
   }
   await walk({
-    fs: fs4,
+    fs: fs2,
     dir,
     // cache, gitdir,
     trees: [TREE({ ref }), STAGE()],
@@ -23938,7 +23938,7 @@ async function commit({ fs: fs4, dir, ref, author, message }) {
   });
   const tree = await createTree("/", fileStates);
   return doCommit({
-    fs: fs4,
+    fs: fs2,
     dir,
     author,
     message,
@@ -24497,6 +24497,38 @@ async function generateProjectId(args) {
   return void 0;
 }
 
+// ../../sdk/dist/telemetry/capture.js
+init_define_ENV_DEFINED_IN_BUILD_STEP();
+
+// ../../sdk/dist/env-variables/index.js
+init_define_ENV_DEFINED_IN_BUILD_STEP();
+var ENV_VARIABLES = {
+  PUBLIC_POSTHOG_TOKEN: "phc_m5yJZCxjOGxF8CJvP5sQ3H0d76xpnLrsmiZHduT4jDz"
+};
+
+// ../../sdk/dist/telemetry/capture.js
+var capture = async (event, args) => {
+  if (ENV_VARIABLES.PUBLIC_POSTHOG_TOKEN === void 0) {
+    return;
+  }
+  try {
+    await fetch("https://eu.posthog.com/capture/", {
+      method: "POST",
+      body: JSON.stringify({
+        api_key: ENV_VARIABLES.PUBLIC_POSTHOG_TOKEN,
+        event,
+        // id is "unknown" because no user information is available
+        distinct_id: "unknown",
+        properties: {
+          $groups: { project: args.projectId },
+          ...args.properties
+        }
+      })
+    });
+  } catch (e) {
+  }
+};
+
 // ../../sdk/dist/loadProject.js
 var settingsCompiler = import_compiler3.TypeCompiler.Compile(ProjectSettings);
 async function loadProject(args) {
@@ -24511,30 +24543,26 @@ Valid examples:
 - "/path/to/green-elephant.inlang
 `, { argument: "projectPath" });
   }
-  let fs4;
+  let fs2;
   if (args.nodeishFs) {
-    fs4 = args.nodeishFs;
+    fs2 = args.nodeishFs;
   } else if (args.repo) {
-    fs4 = args.repo.nodeishFs;
+    fs2 = args.repo.nodeishFs;
   } else {
     throw new LoadProjectInvalidArgument(`Repo missing from arguments.`, { argument: "repo" });
   }
   const nodeishFs = createNodeishFsWithAbsolutePaths({
     projectPath,
-    nodeishFs: fs4
+    nodeishFs: fs2
   });
-  await maybeMigrateToDirectory({ nodeishFs: fs4, projectPath });
+  await maybeMigrateToDirectory({ nodeishFs: fs2, projectPath });
   await maybeCreateFirstProjectId({ projectPath, repo: args.repo });
   return await createRoot2(async () => {
+    const { data: projectId } = await tryCatch(() => fs2.readFile(args.projectPath + "/project_id", { encoding: "utf-8" }));
     const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
     const [settings, _setSettings] = createSignal2();
     createEffect2(() => {
-      loadSettings({ settingsFilePath: projectPath + "/settings.json", nodeishFs }).then((settings2) => {
-        var _a;
-        setSettings(settings2);
-        const project_settings = settings2;
-        (_a = args._capture) == null ? void 0 : _a.call(args, "SDK used settings", { project_settings });
-      }).catch((err) => {
+      loadSettings({ settingsFilePath: projectPath + "/settings.json", nodeishFs }).then((settings2) => setSettings(settings2)).catch((err) => {
         markInitAsFailed(err);
       });
     });
@@ -24572,10 +24600,10 @@ Valid examples:
         markInitAsFailed(void 0);
         return;
       }
-      const loadAndSetMessages = async (fs5) => {
+      const loadAndSetMessages = async (fs3) => {
         makeTrulyAsync(_resolvedModules.resolvedPluginApi.loadMessages({
           settings: settingsValue,
-          nodeishFs: fs5
+          nodeishFs: fs3
         })).then((messages2) => {
           setMessages(messages2);
           markInitAsComplete();
@@ -24644,6 +24672,20 @@ Valid examples:
     createEffect2(() => {
       debouncedSave(messagesQuery.getAll());
     });
+    let projectLoadedCapturedAlready = false;
+    if (projectId && projectLoadedCapturedAlready === false) {
+      projectLoadedCapturedAlready = true;
+      await capture("SDK loaded project", {
+        projectId,
+        properties: {
+          appId: args.appId,
+          settings: settings(),
+          installedPluginIds: installedPlugins().map((p) => p.id),
+          installedMessageLintRuleIds: installedMessageLintRules().map((r) => r.id),
+          numberOfMessages: messagesQuery.includedMessageIds().length
+        }
+      });
+    }
     return {
       installed: {
         plugins: createSubscribable(() => installedPlugins()),
@@ -24652,8 +24694,6 @@ Valid examples:
       errors: createSubscribable(() => [
         ...initializeError ? [initializeError] : [],
         ...resolvedModules() ? resolvedModules().errors : []
-        // have a query error exposed
-        //...(lintErrors() ?? []),
       ]),
       settings: createSubscribable(() => settings()),
       setSettings,
@@ -29069,12 +29109,12 @@ var telemetry = new Proxy(posthog, {
     if (publicEnv.PUBLIC_POSTHOG_TOKEN === void 0) {
       return () => void 0;
     } else if (prop === "capture") {
-      return capture;
+      return capture2;
     }
     return target[prop];
   }
 });
-function capture(args) {
+function capture2(args) {
   return posthog.capture({
     ...args,
     distinctId: "unknown"
@@ -29285,7 +29325,7 @@ export function isAvailableLanguageTag(thing) {
 };
 
 // src/cli/commands/compile.ts
-import fs from "node:fs/promises";
+import nodeFsPromises from "node:fs/promises";
 import { resolve } from "node:path";
 import { Command } from "commander";
 
@@ -29294,32 +29334,30 @@ init_define_ENV_DEFINED_IN_BUILD_STEP();
 import path from "node:path";
 import crypto2 from "node:crypto";
 var previousOutputHash;
-async function writeOutput(outputDirectory, output, fs4) {
+async function writeOutput(outputDirectory, output, fs2) {
   const currentOutputHash = hashOutput(output, outputDirectory);
   if (currentOutputHash === previousOutputHash)
     return;
-  await fs4.access(outputDirectory).catch(async () => {
-    await fs4.mkdir(outputDirectory, { recursive: true });
+  await fs2.access(outputDirectory).catch(async () => {
+    await fs2.mkdir(outputDirectory, { recursive: true });
   });
-  const files = await fs4.readdir(outputDirectory);
+  const files = await fs2.readdir(outputDirectory);
   await Promise.allSettled(
     files.map(async (file) => {
-      await fs4.unlink(outputDirectory + "/" + file);
+      await fs2.unlink(outputDirectory + "/" + file);
     })
   );
   await Promise.allSettled(
     Object.keys(output).map(async (filePath) => {
       const fullPath = path.resolve(outputDirectory, filePath);
       const directory = path.dirname(fullPath);
-      await fs4.mkdir(directory, { recursive: true });
+      await fs2.mkdir(directory, { recursive: true });
     })
   );
   await Promise.allSettled(
     Object.entries(output).map(async ([filePath, fileContent]) => {
       const fullPath = path.resolve(outputDirectory, filePath);
-      await fs4.writeFile(fullPath, fileContent, {
-        encoding: "utf-8"
-      });
+      await fs2.writeFile(fullPath, fileContent);
     })
   );
   previousOutputHash = currentOutputHash;
@@ -29399,51 +29437,22 @@ var compileCommand = new Command().name("compile").summary("Compiles inlang Para
   const path3 = resolve(process.cwd(), options.project);
   const outputDirectory = resolve(process.cwd(), options.outdir);
   logger.info(`Compiling inlang project at "${options.project}".`);
-  const repoRoot = await findRepoRoot({ nodeishFs: fs, path: path3 });
-  let project;
+  const repoRoot = await findRepoRoot({ nodeishFs: nodeFsPromises, path: path3 });
+  const repo = await openRepository(repoRoot || process.cwd(), {
+    nodeishFs: nodeFsPromises
+  });
   if (!repoRoot) {
     logger.warn(`Could not find repository root for path ${path3}`);
-    project = exitIfErrors(
-      await loadProject({
-        projectPath: path3,
-        nodeishFs: fs,
-        _capture(id, props) {
-          telemetry.capture({
-            // @ts-ignore the event types
-            event: id,
-            properties: props
-          });
-        }
-      }),
-      logger
-    );
-  } else {
-    const repo = await openRepository(repoRoot, {
-      nodeishFs: fs
-    });
-    project = exitIfErrors(
-      await loadProject({
-        projectPath: path3,
-        repo,
-        _capture(id, props) {
-          telemetry.capture({
-            // @ts-ignore the event types
-            event: id,
-            properties: props
-          });
-        }
-      }),
-      logger
-    );
-  }
-  async function execute() {
-    const output = compile({
-      messages: project.query.messages.getAll(),
-      settings: project.settings()
-    });
-    await writeOutput(outputDirectory, output, fs);
   }
-  await execute();
+  const project = exitIfErrors(
+    await loadProject({
+      projectPath: path3,
+      repo,
+      appId: "library.inlang.paraglideJs"
+    }),
+    logger
+  );
+  await executeCompilation(project, outputDirectory, repo.nodeishFs);
   if (options.watch) {
     process.on("SIGINT", () => {
       logger.ln().info("Stopping the watcher.");
@@ -29457,7 +29466,7 @@ var compileCommand = new Command().name("compile").summary("Compiles inlang Para
       if (numChanges === 1)
         return;
       logger.info("Messages changed. Recompiling...");
-      await execute();
+      await executeCompilation(project, outputDirectory, repo.nodeishFs);
     });
     while (true) {
       await new Promise((resolve3) => setTimeout(resolve3, 1e4));
@@ -29465,6 +29474,13 @@ var compileCommand = new Command().name("compile").summary("Compiles inlang Para
   }
   logger.info("Sucessfully compiled the project.");
 });
+async function executeCompilation(project, outputDirectory, fs2) {
+  const output = compile({
+    messages: project.query.messages.getAll(),
+    settings: project.settings()
+  });
+  await writeOutput(outputDirectory, output, fs2);
+}
 var exitIfErrors = (project, logger) => {
   if (project.errors().length > 0) {
     logger.warn(`The project has errors:`);
@@ -29479,8 +29495,6 @@ var exitIfErrors = (project, logger) => {
 // src/cli/commands/init.ts
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 import { Command as Command2 } from "commander";
-import fs3 from "node:fs/promises";
-import fsSync from "node:fs";
 import consola2 from "consola";
 import { resolve as resolve2 } from "node:path";
 import { detectJsonFormatting } from "@inlang/detect-json-formatting";
@@ -29490,7 +29504,7 @@ import childProcess from "node:child_process";
 // src/cli/state.ts
 init_define_ENV_DEFINED_IN_BUILD_STEP();
 import path2 from "node:path";
-import fs2 from "node:fs";
+import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 var version = (() => {
   const currentFilePath = fileURLToPath(import.meta.url).split(path2.sep).join(path2.posix.sep);
@@ -29498,31 +29512,42 @@ var version = (() => {
     0,
     currentFilePath.indexOf("/paraglide-js/") + "/paraglide-js".length
   );
-  return JSON.parse(fs2.readFileSync(`${paraglideDirectory}/package.json`, "utf-8")).version;
+  return JSON.parse(fs.readFileSync(`${paraglideDirectory}/package.json`, "utf-8")).version;
 })();
 
 // src/cli/commands/init.ts
 import dedent2 from "dedent";
+import nodeFsPromises2 from "node:fs/promises";
 var DEFAULT_PROJECT_PATH = "./project.inlang";
 var initCommand = new Command2().name("init").summary("Initializes inlang Paraglide-JS.").action(async () => {
-  const logger = new Logger({ silent: false, prefix: false });
-  logger.box("Welcome to inlang Paraglide-JS \u{1FA82}");
+  const repoRoot = await findRepoRoot({
+    nodeishFs: nodeFsPromises2,
+    path: process.cwd()
+  });
+  const repo = await openRepository(repoRoot ?? process.cwd(), {
+    nodeishFs: nodeFsPromises2
+  });
+  const ctx = {
+    logger: new Logger({ silent: false, prefix: false }),
+    repo
+  };
+  ctx.logger.box("Welcome to inlang Paraglide-JS \u{1FA82}");
   telemetry.capture({ event: "PARAGLIDE-JS init started" });
-  await checkIfUncommittedChanges(logger);
-  await checkIfPackageJsonExists(logger);
-  const projectPath = await initializeInlangProject(logger);
+  await checkIfUncommittedChanges(ctx);
+  await checkIfPackageJsonExists(ctx);
+  const projectPath = await initializeInlangProject(ctx);
   telemetry.capture({ event: "PARAGLIDE-JS init project initialized" });
-  await addParaglideJsToDevDependencies(logger);
+  await addParaglideJsToDevDependencies(ctx);
   telemetry.capture({ event: "PARAGLIDE-JS init added to devDependencies" });
-  await addCompileStepToPackageJSON({ projectPath }, logger);
+  await addCompileStepToPackageJSON({ projectPath }, ctx);
   telemetry.capture({ event: "PARAGLIDE-JS init added compile commands" });
-  await maybeChangeTsConfigModuleResolution(logger);
-  await maybeChangeTsConfigAllowJs(logger);
-  await maybeAddVsCodeExtension({ projectPath }, logger);
+  await maybeChangeTsConfigModuleResolution(ctx);
+  await maybeChangeTsConfigAllowJs(ctx);
+  await maybeAddVsCodeExtension({ projectPath }, ctx);
   telemetry.capture({ event: "PARAGLIDE-JS init finished" });
   const absoluteSettingsPath = resolve2(projectPath, "settings.json");
   const relativeSettingsFilePath = absoluteSettingsPath.replace(process.cwd(), ".");
-  logger.box(
+  ctx.logger.box(
     dedent2`inlang Paraglide-JS has been set up sucessfully.
 			
 			1. Run your install command (npm i, yarn install, etc)
@@ -29534,28 +29559,31 @@ var initCommand = new Command2().name("init").summary("Initializes inlang Paragl
 			`
   );
 });
-var initializeInlangProject = async (logger) => {
-  const existingProjectPath = await findExistingInlangProjectPath();
+var initializeInlangProject = async (ctx) => {
+  const existingProjectPath = await findExistingInlangProjectPath(ctx);
   if (existingProjectPath) {
-    await existingProjectFlow({ existingProjectPath }, logger);
+    await existingProjectFlow({ existingProjectPath }, ctx);
     return existingProjectPath;
   } else {
-    await createNewProjectFlow(logger);
+    await createNewProjectFlow(ctx);
     return DEFAULT_PROJECT_PATH;
   }
 };
-var maybeAddVsCodeExtension = async (args, logger) => {
-  const response = await prompt(`Are you using VSCode?`, {
-    type: "confirm",
-    initial: true
-  });
-  if (response === false) {
-    return;
+var maybeAddVsCodeExtension = async (args, ctx) => {
+  var _a;
+  const isCertainlyVsCode = ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.TERM_PROGRAM) === "vscode";
+  let response = isCertainlyVsCode;
+  if (!isCertainlyVsCode) {
+    response = await prompt(`Are you using VSCode?`, {
+      type: "confirm",
+      initial: true
+    });
   }
+  if (response === false)
+    return;
   const project = await loadProject({
     projectPath: resolve2(process.cwd(), args.projectPath),
-    //@ts-ignore
-    nodeishFs: fs3
+    repo: ctx.repo
   });
   const settings = project.settings();
   if (settings.modules.some((m) => m.includes("plugin-m-function-matcher")) === false) {
@@ -29566,7 +29594,9 @@ var maybeAddVsCodeExtension = async (args, logger) => {
   }
   let extensions = {};
   try {
-    extensions = JSON5.parse(await fs3.readFile("./.vscode/extensions.json", { encoding: "utf-8" }));
+    extensions = JSON5.parse(
+      await ctx.repo.nodeishFs.readFile("./.vscode/extensions.json", { encoding: "utf-8" })
+    );
   } catch {
   }
   if (extensions.recommendations === void 0) {
@@ -29574,34 +29604,45 @@ var maybeAddVsCodeExtension = async (args, logger) => {
   }
   if (extensions.recommendations.includes("inlang.vs-code-extension") === false) {
     extensions.recommendations.push("inlang.vs-code-extension");
-    if (fsSync.existsSync("./.vscode") === false) {
-      await fs3.mkdir("./.vscode");
+    if (await fileExists("./.vscode", ctx.repo.nodeishFs) === false) {
+      await ctx.repo.nodeishFs.mkdir("./.vscode");
     }
-    await fs3.writeFile("./.vscode/extensions.json", JSON.stringify(extensions, void 0, 2));
-    logger.success("Added the inlang vs code extension to the workspace recommendations.");
+    await ctx.repo.nodeishFs.writeFile(
+      "./.vscode/extensions.json",
+      JSON.stringify(extensions, void 0, 2)
+    );
+    ctx.logger.success("Added the inlang vs code extension to the workspace recommendations.");
   }
 };
-var addParaglideJsToDevDependencies = async (logger) => {
-  const file = await fs3.readFile("./package.json", { encoding: "utf-8" });
+var addParaglideJsToDevDependencies = async (ctx) => {
+  const file = await ctx.repo.nodeishFs.readFile("./package.json", { encoding: "utf-8" });
   const stringify = detectJsonFormatting(file);
-  const pkg = JSON.parse(file);
+  let pkg = {};
+  try {
+    pkg = JSON.parse(file);
+  } catch {
+    ctx.logger.error(
+      `Your ./package.json does not contain valid JSON. Please fix it and try again.`
+    );
+    process.exit(1);
+  }
   if (pkg.devDependencies === void 0) {
     pkg.devDependencies = {};
   }
   pkg.devDependencies["@inlang/paraglide-js"] = version;
-  await fs3.writeFile("./package.json", stringify(pkg));
-  logger.success("Added @inlang/paraglide-js to the devDependencies in package.json.");
+  await ctx.repo.nodeishFs.writeFile("./package.json", stringify(pkg));
+  ctx.logger.success("Added @inlang/paraglide-js to the devDependencies in package.json.");
 };
-var findExistingInlangProjectPath = async () => {
+var findExistingInlangProjectPath = async (ctx) => {
   for (const path3 of ["./project.inlang", "../project.inlang", "../../project.inlang"]) {
-    if (fsSync.existsSync(path3)) {
+    if (await fileExists(path3, ctx.repo.nodeishFs)) {
       return path3;
     }
     continue;
   }
   return void 0;
 };
-var existingProjectFlow = async (args, logger) => {
+var existingProjectFlow = async (args, ctx) => {
   const selection = await prompt(
     `Do you want to use the inlang project at "${args.existingProjectPath}" or create a new project?`,
     {
@@ -29613,43 +29654,41 @@ var existingProjectFlow = async (args, logger) => {
     }
   );
   if (selection === "newProject") {
-    return createNewProjectFlow(logger);
+    return createNewProjectFlow(ctx);
   }
   const project = await loadProject({
     projectPath: resolve2(process.cwd(), args.existingProjectPath),
-    //@ts-ignore
-    nodeishFs: fs3
+    repo: ctx.repo
   });
   if (project.errors().length > 0) {
-    logger.error("The project contains errors: ");
+    ctx.logger.error("The project contains errors: ");
     for (const error of project.errors()) {
-      logger.error(error);
+      ctx.logger.error(error);
     }
     process.exit(1);
   }
 };
-var createNewProjectFlow = async (logger) => {
-  logger.info(`Creating a new inlang project in the current working directory.`);
-  await fs3.mkdir(DEFAULT_PROJECT_PATH, { recursive: true });
-  await fs3.writeFile(
+var createNewProjectFlow = async (ctx) => {
+  ctx.logger.info(`Creating a new inlang project in the current working directory.`);
+  await ctx.repo.nodeishFs.mkdir(DEFAULT_PROJECT_PATH, { recursive: true });
+  await ctx.repo.nodeishFs.writeFile(
     DEFAULT_PROJECT_PATH + "/settings.json",
     JSON.stringify(newProjectTemplate, void 0, 2)
   );
   const project = await loadProject({
     projectPath: resolve2(process.cwd(), DEFAULT_PROJECT_PATH),
-    //@ts-ignore
-    nodeishFs: fs3
+    repo: ctx.repo
   });
   if (project.errors().length > 0) {
-    logger.warn(
+    ctx.logger.warn(
       "Failed to create a new inlang project.\n\nThis is likely an internal bug. Please file an issue at https://github.com/opral/monorepo."
     );
     for (const error of project.errors()) {
-      logger.error(error);
+      ctx.logger.error(error);
     }
     return process.exit(1);
   } else {
-    logger.success("Successfully created a new inlang project.");
+    ctx.logger.success("Successfully created a new inlang project.");
   }
 };
 var newProjectTemplate = {
@@ -29676,20 +29715,21 @@ var newProjectTemplate = {
     pathPattern: "./messages/{languageTag}.json"
   }
 };
-var checkIfPackageJsonExists = async (logger) => {
-  if (fsSync.existsSync("./package.json") === false) {
-    logger.warn(
+var checkIfPackageJsonExists = async (ctx) => {
+  const exists = await fileExists("./package.json", ctx.repo.nodeishFs);
+  if (exists === false) {
+    ctx.logger.warn(
       "No package.json found in the current working directory. Please change the working directory to the directory with a package.json file."
     );
     return process.exit(0);
   }
 };
-var checkIfUncommittedChanges = async (logger) => {
+var checkIfUncommittedChanges = async (ctx) => {
   try {
-    if (childProcess.execSync("git status --porcelain").toString().length === 0) {
+    if ((await execAsync("git status --porcelain")).toString().length === 0) {
       return;
     }
-    logger.info(
+    ctx.logger.info(
       `You have uncommitted changes.
 
 Please commit your changes before initializing inlang Paraglide-JS. Committing outstanding changes ensures that you don't lose any work, and see the changes the paraglide-js init command introduces.`
@@ -29710,9 +29750,9 @@ Please commit your changes before initializing inlang Paraglide-JS. Committing o
     return;
   }
 };
-var addCompileStepToPackageJSON = async (args, logger) => {
+var addCompileStepToPackageJSON = async (args, ctx) => {
   var _a, _b;
-  const file = await fs3.readFile("./package.json", { encoding: "utf-8" });
+  const file = await ctx.repo.nodeishFs.readFile("./package.json", { encoding: "utf-8" });
   const stringify = detectJsonFormatting(file);
   const pkg = JSON.parse(file);
   if (pkg.scripts === void 0) {
@@ -29728,7 +29768,7 @@ var addCompileStepToPackageJSON = async (args, logger) => {
   } else if (((_b = pkg == null ? void 0 : pkg.scripts) == null ? void 0 : _b.build.includes("paraglide-js compile")) === false) {
     pkg.scripts.build = `paraglide-js compile --project ${args.projectPath} && ${pkg.scripts.build}`;
   } else {
-    logger.warn(`The "build" script in the \`package.json\` already contains a "paraglide-js compile" command.
+    ctx.logger.warn(`The "build" script in the \`package.json\` already contains a "paraglide-js compile" command.
 
 Please add the following command to your build script manually:
 
@@ -29741,30 +29781,32 @@ Please add the following command to your build script manually:
       }
     );
     if (response === false) {
-      logger.log("Please add the paraglide-js compile to your build script and try again.");
+      ctx.logger.log("Please add the paraglide-js compile to your build script and try again.");
       return process.exit(0);
     } else {
       return;
     }
   }
-  await fs3.writeFile("./package.json", stringify(pkg));
-  logger.success("Successfully added the compile command to the build step in package.json.");
+  await ctx.repo.nodeishFs.writeFile("./package.json", stringify(pkg));
+  ctx.logger.success("Successfully added the compile command to the build step in package.json.");
 };
-var maybeChangeTsConfigModuleResolution = async (logger) => {
+var maybeChangeTsConfigModuleResolution = async (ctx) => {
   var _a, _b, _c;
-  if (fsSync.existsSync("./tsconfig.json") === false) {
+  if (await fileExists("./tsconfig.json", ctx.repo.nodeishFs) === false) {
     return;
   }
-  const file = await fs3.readFile("./tsconfig.json", { encoding: "utf-8" });
+  const file = await ctx.repo.nodeishFs.readFile("./tsconfig.json", { encoding: "utf-8" });
   const tsconfig = JSON5.parse(file);
   let parentTsConfig;
   if (tsconfig.extends) {
     try {
       const parentTsConfigPath = resolve2(process.cwd(), tsconfig.extends);
-      const parentTsConfigFile = await fs3.readFile(parentTsConfigPath, { encoding: "utf-8" });
+      const parentTsConfigFile = await ctx.repo.nodeishFs.readFile(parentTsConfigPath, {
+        encoding: "utf-8"
+      });
       parentTsConfig = JSON5.parse(parentTsConfigFile);
     } catch {
-      logger.warn(
+      ctx.logger.warn(
         `The tsconfig.json is extended from a tsconfig that couldn't be read. Maybe the file doesn't exist yet or is a NPM package. Continuing without taking the extended from tsconfig into consideration.`
       );
     }
@@ -29774,7 +29816,7 @@ var maybeChangeTsConfigModuleResolution = async (logger) => {
   if (moduleResolution && invalidOptions.includes(moduleResolution.toLowerCase()) === false) {
     return;
   }
-  logger.info(
+  ctx.logger.info(
     `You need to set the \`compilerOptions.moduleResolution\` to "Bundler" in the \`tsconfig.json\` file:
 
 \`{
@@ -29793,32 +29835,34 @@ var maybeChangeTsConfigModuleResolution = async (logger) => {
       }
     );
     if (response === false) {
-      logger.warn("Continuing without adjusting the tsconfig.json. This may lead to type errors.");
+      ctx.logger.warn(
+        "Continuing without adjusting the tsconfig.json. This may lead to type errors."
+      );
       return;
     }
-    const file2 = await fs3.readFile("./tsconfig.json", { encoding: "utf-8" });
+    const file2 = await ctx.repo.nodeishFs.readFile("./tsconfig.json", { encoding: "utf-8" });
     const tsconfig2 = JSON5.parse(file2);
     if (((_c = tsconfig2 == null ? void 0 : tsconfig2.compilerOptions) == null ? void 0 : _c.moduleResolution) && tsconfig2.compilerOptions.moduleResolution.toLowerCase() === "bundler") {
       isValid2 = true;
       return;
     } else {
-      logger.error(
+      ctx.logger.error(
         "The compiler options have not been adjusted. Please set the `compilerOptions.moduleResolution` to `Bundler`."
       );
     }
   }
 };
-var maybeChangeTsConfigAllowJs = async (logger) => {
+var maybeChangeTsConfigAllowJs = async (ctx) => {
   var _a, _b;
-  if (fsSync.existsSync("./tsconfig.json") === false) {
+  if (await fileExists("./tsconfig.json", ctx.repo.nodeishFs) === false) {
     return;
   }
-  const file = await fs3.readFile("./tsconfig.json", { encoding: "utf-8" });
+  const file = await ctx.repo.nodeishFs.readFile("./tsconfig.json", { encoding: "utf-8" });
   const tsconfig = JSON5.parse(file);
   if (((_a = tsconfig.compilerOptions) == null ? void 0 : _a.allowJs) === true) {
     return;
   }
-  logger.info(
+  ctx.logger.info(
     `You need to set the \`compilerOptions.allowJs\` to \`true\` in the \`tsconfig.json\` file:
 
 \`{
@@ -29834,16 +29878,18 @@ var maybeChangeTsConfigAllowJs = async (logger) => {
       initial: true
     });
     if (response === false) {
-      logger.warn("Continuing without adjusting the tsconfig.json. This may lead to type errors.");
+      ctx.logger.warn(
+        "Continuing without adjusting the tsconfig.json. This may lead to type errors."
+      );
       return;
     }
-    const file2 = await fs3.readFile("./tsconfig.json", { encoding: "utf-8" });
+    const file2 = await ctx.repo.nodeishFs.readFile("./tsconfig.json", { encoding: "utf-8" });
     const tsconfig2 = JSON5.parse(file2);
     if (((_b = tsconfig2 == null ? void 0 : tsconfig2.compilerOptions) == null ? void 0 : _b.allowJs) === true) {
       isValid2 = true;
       return;
     } else {
-      logger.error(
+      ctx.logger.error(
         "The compiler options have not been adjusted. Please set the `compilerOptions.allowJs` to `true`."
       );
     }
@@ -29856,6 +29902,29 @@ var prompt = async (message, options) => {
   }
   return response;
 };
+async function fileExists(filePath, nodeishFs) {
+  try {
+    await nodeishFs.stat(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    } else {
+      throw new Error(`Failed to check if file exists: ${error}`, { cause: error });
+    }
+  }
+}
+function execAsync(command) {
+  return new Promise((resolve3, reject) => {
+    childProcess.exec(command, (error, stdout) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve3(stdout);
+      }
+    });
+  });
+}
 
 // src/cli/main.ts
 var cli = new Command3().name("paraglide-js").addCommand(compileCommand).addCommand(initCommand).showHelpAfterError().version(version);

package/dist/services/file-handling/write-output.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" resolution-mode="require"/>
-import type nodeFsPromises from "node:fs/promises";
-export declare function writeOutput(outputDirectory: string, output: Record<string, string>, fs: typeof nodeFsPromises): Promise<void>;
+import type { NodeishFilesystem } from "@lix-js/fs";
+export declare function writeOutput(outputDirectory: string, output: Record<string, string>, fs: NodeishFilesystem): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -37,14 +37,15 @@
     "isomorphic-git": "1.24.5",
     "json5": "2.2.3",
     "posthog-node": "3.1.3",
-    "@inlang/language-tag": "1.3.0",
-    "@inlang/detect-json-formatting": "1.0.0"
+    "@inlang/detect-json-formatting": "1.0.0",
+    "@inlang/language-tag": "1.4.0"
   },
   "devDependencies": {
     "@rollup/plugin-terser": "0.4.3",
     "@rollup/plugin-virtual": "3.0.1",
     "@ts-morph/bootstrap": "0.20.0",
     "@types/minimist": "1.2.3",
+    "@types/node": "^20.11.2",
     "@vitest/coverage-v8": "0.34.3",
     "cross-env": "^7.0.3",
     "esbuild": "^0.19.7",
@@ -52,11 +53,12 @@
     "rollup": "3.29.1",
     "typescript": "5.2.2",
     "vitest": "0.34.3",
-    "@lix-js/client": "0.5.0",
     "@inlang/env-variables": "0.2.0",
-    "@inlang/telemetry": "0.3.3",
-    "@inlang/sdk": "0.22.0",
-    "@lix-js/fs": "0.5.0"
+    "@inlang/sdk": "0.23.0",
+    "@inlang/telemetry": "0.3.4",
+    "@lix-js/client": "0.5.0",
+    "@lix-js/fs": "0.5.0",
+    "@inlang/plugin-message-format": "2.0.0"
   },
   "exports": {
     "./internal": {