@inlang/paraglide-js 1.10.1 → 1.11.0

package/README.md

@@ -1,7 +1,3 @@
----
-title: "Getting Started"
-description: "Learn how to install the ParaglideJS i18n library in your project"
----
 [![Inlang-ecosystem compatibility badge](https://cdn.jsdelivr.net/gh/opral/monorepo@main/inlang/assets/md-badges/inlang.svg)](https://inlang.com)
 
 # Getting started

package/dist/adapter-utils/index.js

@@ -1,28 +1,24 @@
 function negotiateLanguagePreferences(accept, availableLanguageTags) {
-  if (availableLanguageTags.length === 0)
-    return [];
   accept ||= "*";
   const acceptLanguageSpecs = parseAcceptLanguageHeader(accept);
   const priorities = availableLanguageTags.map(
     (languageTag, index) => getHighestLanguagePriority(languageTag, acceptLanguageSpecs, index)
   );
-  return priorities.filter((prio) => prio.quality > 0).sort(comparePriorities).map((priority) => priority.languageTag);
+  return priorities.filter((prio) => prio.quality > 0).sort(bySpecificity).sort(byQuality).map((priority) => priority.languageTag);
 }
 function parseAcceptLanguageHeader(acceptLanguage) {
-  const acceptableLanguageDefinitions = acceptLanguage.split(",");
-  const specs = acceptableLanguageDefinitions.map((dfn) => dfn.trim()).map((dfn, index) => parseLanguage(dfn, index)).filter((maybeSpec) => Boolean(maybeSpec));
-  return specs;
+  return acceptLanguage.split(",").map((dfn) => dfn.trim()).map((dfn, index) => parseLanguage(dfn, index)).filter((maybeSpec) => Boolean(maybeSpec));
 }
-function parseLanguage(str, index) {
+function parseLanguage(languageTag, index) {
   const LANGUAGE_REGEXP = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
-  const match = LANGUAGE_REGEXP.exec(str);
+  const match = LANGUAGE_REGEXP.exec(languageTag);
   if (!match)
     return void 0;
   const [, prefix, suffix, qualityMatch] = match;
   if (!prefix)
-    throw new Error(`Invalid language tag: ${str}`);
+    throw new Error(`Invalid language tag: ${languageTag}`);
   const full = suffix ? `${prefix}-${suffix}` : prefix;
-  const quality = qualityMatch ? parseQuality(qualityMatch) ?? 1 : 1;
+  const quality = parseQuality(qualityMatch ?? "") ?? 1;
   return {
     prefix,
     suffix,
@@ -32,61 +28,43 @@ function parseLanguage(str, index) {
   };
 }
 function parseQuality(qualityMatch) {
-  const params = qualityMatch.split(";");
-  for (const param of params) {
-    const [key, value] = param.split("=");
-    if (key === "q" && value)
-      return parseFloat(value);
-  }
-  return void 0;
+  return qualityMatch.split(";").map((param) => param.split("=")).filter((p) => p[0] == "q" && !!p[1]).map(([, value]) => parseFloat(value))[0];
 }
-function getHighestLanguagePriority(availableLanguageTag, acceptableLanguages, index) {
-  let highestPriority = {
-    languageTag: availableLanguageTag,
+function getHighestLanguagePriority(languageTag, acceptableLanguages, index) {
+  const priorities = acceptableLanguages.map((spec) => calculatePriority(languageTag, spec, index)).filter((prio) => Boolean(prio));
+  const highestPriority = priorities.sort(bySpecificity)[0] || {
+    languageTag,
     index: 0,
     order: -1,
     quality: 0,
     specificity: 0
   };
-  for (const acceptableLanguage of acceptableLanguages) {
-    const priority = calculatePriority(availableLanguageTag, acceptableLanguage, index);
-    if (!priority)
-      continue;
-    if (
-      //compare the calculated priority to the highest priority ignoring quality.
-      (highestPriority.specificity - priority.specificity || highestPriority.quality - priority.quality || highestPriority.order - priority.order) < 0
-    ) {
-      highestPriority = priority;
-    }
-  }
   return highestPriority;
 }
-function calculatePriority(language, spec, index) {
-  const parsed = parseLanguage(language, 0);
+function calculatePriority(languageTag, spec, index) {
+  const parsed = parseLanguage(languageTag, 0);
   if (!parsed)
     return void 0;
   let specificity = 0;
   if (spec.full.toLowerCase() === parsed.full.toLowerCase()) {
-    specificity |= 4;
+    specificity = 4;
   } else if (spec.prefix.toLowerCase() === parsed.full.toLowerCase()) {
-    specificity |= 2;
+    specificity = 2;
   } else if (spec.full.toLowerCase() === parsed.prefix.toLowerCase()) {
-    specificity |= 1;
+    specificity = 1;
   }
-  if (specificity === 0 && spec.full !== "*") {
+  if (specificity === 0 && spec.full !== "*")
     return void 0;
-  }
   return {
-    languageTag: language,
+    languageTag,
     index,
     order: spec.index,
     quality: spec.quality,
     specificity
   };
 }
-function comparePriorities(a, b) {
-  return b.quality - a.quality || b.specificity - a.specificity || a.order - b.order || a.index - b.index || 0;
-}
+const byQuality = (a, b) => b.quality - a.quality;
+const bySpecificity = (a, b) => b.specificity - a.specificity || a.order - b.order || a.index - b.index;
 function detectLanguageFromPath({
   path,
   availableLanguageTags,

package/dist/cli/index.js

@@ -1,6 +1,6 @@
 var _a, _b;
 import { Command } from "commander";
-import { p as pattern, c as assertValidProjectPath, d as pathExists$1, e as getDefaultExportFromCjs, g as getDirname, a as getBasename, f as parseOrigin, t as transformRemote, h as commonjsGlobal, i as getAugmentedNamespace, j as parseLixUri, w as withProxy, compile, writeOutput, Logger, l as loadProject, classifyProjectErrors, k as typebox, b as normalizePath$2, v as value, m as telemetry, o as pathExists$2, q as findPackageJson } from "../index.js";
+import { p as pattern, b as assertValidProjectPath, c as getDefaultExportFromCjs, g as getDirname, a as getBasename, d as parseOrigin, t as transformRemote, e as commonjsGlobal, f as getAugmentedNamespace, h as parseLixUri, w as withProxy, compile, writeOutput, Logger, l as loadProject, classifyProjectErrors, i as typebox, n as normalizePath$2, v as value, j as telemetry, k as pathExists$1, m as findPackageJson } from "../index.js";
 import dedent from "dedent";
 import nodeFsPromises from "node:fs/promises";
 import * as nodePath from "node:path";
@@ -38,7 +38,7 @@ const defaultProjectSettings = {
 async function createNewProject(args) {
   assertValidProjectPath(args.projectPath);
   const nodeishFs = args.repo.nodeishFs;
-  if (await pathExists$1(args.projectPath, nodeishFs)) {
+  if (await directoryExists(args.projectPath, nodeishFs)) {
     throw new Error(`projectPath already exists, received "${args.projectPath}"`);
   }
   const settingsText = JSON.stringify(args.projectSettings ?? defaultProjectSettings, void 0, 2);
@@ -49,6 +49,18 @@ async function createNewProject(args) {
     nodeishFs.mkdir(`${args.projectPath}/cache/modules`, { recursive: true })
   ]);
 }
+async function directoryExists(filePath, nodeishFs) {
+  try {
+    const stat = await nodeishFs.stat(filePath);
+    return stat.isDirectory();
+  } catch (error) {
+    if (error && "code" in error && error.code === "ENOENT") {
+      return false;
+    } else {
+      throw new Error(`Failed to check if path exists: ${error}`, { cause: error });
+    }
+  }
+}
 var AsyncLock$1 = function(opts) {
   opts = opts || {};
   this.Promise = opts.Promise || Promise;
@@ -6322,7 +6334,7 @@ function compareRefNames(a, b) {
   return tmp;
 }
 const memo = /* @__PURE__ */ new Map();
-function normalizePath$1(path) {
+function normalizePath(path) {
   let normalizedPath = memo.get(path);
   if (!normalizedPath) {
     normalizedPath = normalizePathInternal(path);
@@ -6347,7 +6359,7 @@ function normalizePathInternal(path) {
   return path;
 }
 function join$2(...parts) {
-  return normalizePath$1(parts.map(normalizePath$1).join("/"));
+  return normalizePath(parts.map(normalizePath).join("/"));
 }
 const num = (val) => {
   val = val.toLowerCase();
@@ -6434,7 +6446,7 @@ const lower = (text) => {
 const getPath = (section, subsection, name) => {
   return [lower(section), subsection, lower(name)].filter((a) => a != null).join(".");
 };
-const normalizePath$1$1 = (path) => {
+const normalizePath$1 = (path) => {
   const pathSegments = path.split(".");
   const section = pathSegments.shift();
   const name = pathSegments.pop();
@@ -6479,7 +6491,7 @@ class GitConfig {
     return new GitConfig(text);
   }
   async get(path, getall = false) {
-    const normalizedPath = normalizePath$1$1(path).path;
+    const normalizedPath = normalizePath$1(path).path;
     const allValues = this.parsedConfig.filter((config) => config.path === normalizedPath).map(({ section, name, value: value2 }) => {
       const fn = schema$1[section] && schema$1[section][name];
       return fn ? fn(value2) : value2;
@@ -6507,7 +6519,7 @@ class GitConfig {
       name,
       path: normalizedPath,
       sectionPath
-    } = normalizePath$1$1(path);
+    } = normalizePath$1(path);
     const configIndex = findLastIndex(
       this.parsedConfig,
       (config) => config.path === normalizedPath
@@ -15430,7 +15442,7 @@ var index$1 = {
   _normalizeCommitterObject: normalizeCommitterObject,
   _normalizeMode: normalizeMode,
   _normalizeNewlines: normalizeNewlines,
-  _normalizePath: normalizePath$1,
+  _normalizePath: normalizePath,
   _normalizeStats: normalizeStats,
   _outdent: outdent,
   _padHex: padHex$1,
@@ -15636,11 +15648,11 @@ const {
   STAGE,
   isIgnored
 } = index$1;
-function normalizePath(path) {
+function isoNormalizePath(path) {
   return path.replace(/\/\.\//g, "/").replace(/\/{2,}/g, "/").replace(/^\/\.$/, "/").replace(/^\.\/$/, ".").replace(/^\.\//, "").replace(/\/\.$/, "").replace(/(.+)\/$/, "$1").replace(/^$/, ".");
 }
 function join$1(...parts) {
-  return normalizePath(parts.map(normalizePath).join("/"));
+  return isoNormalizePath(parts.map(isoNormalizePath).join("/"));
 }
 async function statusList(ctx, state, statusArg) {
   return await _statusList({
@@ -23734,7 +23746,7 @@ function makeGithubClient({ gitHubProxyUrl } = {}) {
 }
 async function repoContext(url, args) {
   var _a2;
-  const rawFs = args.nodeishFs || (await import("../index-f9c48389.js")).createNodeishMemoryFs();
+  const rawFs = args.nodeishFs || (await import("../index-9cf8cd4d.js")).createNodeishMemoryFs();
   const author = args.author;
   let debug = args.debug || false;
   if (!url || !url.startsWith("file://") && !url.startsWith("https://") && !url.startsWith("http://")) {
@@ -32314,7 +32326,7 @@ async function isInWorkspaceRecommendation(fs, workingDirectory) {
   return (extensions == null ? void 0 : extensions.recommendations.includes("inlang.vs-code-extension")) || false;
 }
 async function isAdopted$1(args) {
-  return isInWorkspaceRecommendation(args.fs, args.workingDirectory);
+  return await isInWorkspaceRecommendation(args.fs, args.workingDirectory);
 }
 async function add$1(args) {
   await addRecommendationToWorkspace(args.fs, args.workingDirectory);
@@ -32359,7 +32371,7 @@ const maybeChangeTsConfig = async (ctx) => {
 };
 const maybeChangeTsConfigAllowJs = async (ctx) => {
   var _a2, _b2;
-  if (await pathExists$2("./tsconfig.json", ctx.repo.nodeishFs) === false) {
+  if (await pathExists$1("./tsconfig.json", ctx.repo.nodeishFs) === false) {
     return ctx;
   }
   const file = await ctx.repo.nodeishFs.readFile("./tsconfig.json", { encoding: "utf-8" });
@@ -32407,7 +32419,7 @@ const maybeChangeTsConfigAllowJs = async (ctx) => {
 };
 const maybeChangeTsConfigModuleResolution = async (ctx) => {
   var _a2, _b2, _c;
-  if (await pathExists$2("./tsconfig.json", ctx.repo.nodeishFs) === false) {
+  if (await pathExists$1("./tsconfig.json", ctx.repo.nodeishFs) === false) {
     return ctx;
   }
   const file = await ctx.repo.nodeishFs.readFile("./tsconfig.json", { encoding: "utf-8" });
@@ -34555,6 +34567,22 @@ const GitHubActionsWorkflow = typebox.Type.Object({
   jobs: typebox.Type.Record(typebox.Type.String(), GitHubActionJob)
   // Use Record to define an object with string keys and GitHubActionJob values
 });
+async function shouldRecommend(args) {
+  try {
+    await args.fs.stat(".git/config");
+    const configData = await args.fs.readFile(".git/config", { encoding: "utf-8" });
+    const match = configData.match(/url = (.+)/);
+    const remoteOriginUrl = match ? match[1] : void 0;
+    const isNinjaAdopted = await isAdopted({ fs: args.fs });
+    if (remoteOriginUrl && remoteOriginUrl.includes("github.com") && !isNinjaAdopted) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    return false;
+  }
+}
 async function isAdopted(args) {
   async function searchWorkflowFiles(directoryPath, depth = 0) {
     if (depth > 3) {
@@ -34647,7 +34675,7 @@ const maybeAddNinja = async (ctx) => {
   if (response !== true)
     return ctx;
   try {
-    if (!await isAdopted({ fs: ctx.repo.nodeishFs })) {
+    if (!await shouldRecommend({ fs: ctx.repo.nodeishFs })) {
       await add({ fs: ctx.repo.nodeishFs });
       telemetry.capture({ event: "PARAGLIDE JS init added Ninja" });
       ctx.logger.success("Added the 🥷 Ninja Github Action for linting translations");
@@ -34749,7 +34777,7 @@ const addParaglideJsToDevDependencies = async (ctx) => {
   const ctx1 = await updatePackageJson({
     devDependencies: async (devDeps) => ({
       ...devDeps,
-      "@inlang/paraglide-js": "1.10.1"
+      "@inlang/paraglide-js": "1.11.0"
     })
   })(ctx);
   ctx.logger.success("Added @inlang/paraglide-js to the devDependencies in package.json.");
@@ -34824,7 +34852,7 @@ async function promtStack() {
     initial: "other"
   });
 }
-const cli = new Command().name("paraglide-js").addCommand(compileCommand).addCommand(initCommand).showHelpAfterError().version("1.10.1");
+const cli = new Command().name("paraglide-js").addCommand(compileCommand).addCommand(initCommand).showHelpAfterError().version("1.11.0");
 export {
   defaults as Defaults,
   GitPackIndex as G,

package/dist/cli/utils.d.ts

@@ -29,7 +29,7 @@ export type CliStep<In extends object, Out> = <Ctx extends In>(ctx: Ctx) => Prom
  */
 export declare const prompt: typeof consola.prompt;
 export declare const promptSelection: <T extends string>(message: string, options?: {
-    initial?: T | undefined;
+    initial?: T;
     options: {
         label: string;
         value: T;

package/dist/compiler/compilePattern.d.ts

@@ -1,3 +1,5 @@
+import { Pattern } from '@inlang/sdk';
+
 /**
  * Compiles a pattern into a template literal string.
  *
@@ -5,13 +7,7 @@
  *  const { compiled, params } = compilePattern([{ type: "Text", value: "Hello " }, { type: "VariableReference", name: "name" }])
  *  >> compiled === "`Hello ${params.name}`"
  */
-export declare const compilePattern: (pattern: ({
-    type: "Text";
-    value: string;
-} | {
-    type: "VariableReference";
-    name: string;
-})[]) => {
+export declare const compilePattern: (pattern: Pattern) => {
     params: Record<string, "NonNullable<unknown>">;
     compiled: string;
 };

package/dist/{index-f9c48389.js → index-9cf8cd4d.js}

@@ -1,5 +1,4 @@
-import { n as normalPath, g as getDirname, a as getBasename } from "./index.js";
-import { b } from "./index.js";
+import { n as normalizePath, g as getDirname, a as getBasename } from "./index.js";
 import "dedent";
 import "tty";
 import "util";
@@ -62,27 +61,31 @@ function createNodeishMemoryFs() {
   });
   const listeners = /* @__PURE__ */ new Set();
   async function stat(path) {
-    path = normalPath(path);
+    path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
     const stats = state.fsStats.get(path);
-    if (stats === void 0)
+    if (stats === void 0) {
       throw new FilesystemError("ENOENT", path, "stat");
-    if (stats.symlinkTarget)
+    }
+    if (stats.symlinkTarget) {
       return stat(stats.symlinkTarget);
+    }
     return Object.assign({}, stats);
   }
   async function lstat(path) {
-    path = normalPath(path);
+    path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
     const stats = state.fsStats.get(path);
-    if (stats === void 0)
+    if (stats === void 0) {
       throw new FilesystemError("ENOENT", path, "lstat");
-    if (!stats.symlinkTarget)
+    }
+    if (!stats.symlinkTarget) {
       return stat(path);
+    }
     return Object.assign({}, stats);
   }
   return {
     _state: state,
     _createPlaceholder: async function(path, options) {
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const dirName = getDirname(path);
       const baseName = getBasename(path);
       let parentDir = state.fsMap.get(dirName);
@@ -106,7 +109,7 @@ function createNodeishMemoryFs() {
       state.fsMap.set(path, { placeholder: true });
     },
     _isPlaceholder: function(path) {
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const entry = state.fsMap.get(path);
       if (entry && "placeholder" in entry) {
         return true;
@@ -114,18 +117,21 @@ function createNodeishMemoryFs() {
       return false;
     },
     writeFile: async function(path, data, options) {
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const dirName = getDirname(path);
       const baseName = getBasename(path);
       const parentDir = state.fsMap.get(dirName);
       if (!(parentDir instanceof Set))
         throw new FilesystemError("ENOENT", path, "writeFile");
+      let inodeData;
       if (typeof data === "string") {
-        data = Buffer.from(new TextEncoder().encode(data));
+        inodeData = Buffer.from(new TextEncoder().encode(data));
       } else if (!(data instanceof Uint8Array)) {
         throw new FilesystemError('The "data" argument must be of type string/Uint8Array', data, "readFile");
       } else if (!Buffer.isBuffer(data)) {
-        data = Buffer.from(data);
+        inodeData = Buffer.from(data);
+      } else {
+        inodeData = data;
       }
       parentDir.add(baseName);
       newStatEntry({
@@ -134,7 +140,7 @@ function createNodeishMemoryFs() {
         kind: 0,
         modeBits: (options == null ? void 0 : options.mode) ?? 420
       });
-      state.fsMap.set(path, data);
+      state.fsMap.set(path, inodeData);
       for (const listener of listeners) {
         listener({ eventType: "rename", filename: dirName + baseName });
       }
@@ -144,7 +150,7 @@ function createNodeishMemoryFs() {
     //   a string or a Uint8Array based on the options.
     readFile: async function(path, options) {
       const decoder = new TextDecoder();
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const file = state.fsMap.get(path);
       if (file instanceof Set)
         throw new FilesystemError("EISDIR", path, "readFile");
@@ -157,7 +163,7 @@ function createNodeishMemoryFs() {
       return decoder.decode(file);
     },
     readdir: async function(path) {
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const dir = state.fsMap.get(path);
       if (dir instanceof Set)
         return [...dir.keys()];
@@ -166,7 +172,7 @@ function createNodeishMemoryFs() {
       throw new FilesystemError("ENOTDIR", path, "readdir");
     },
     mkdir: async function mkdir(path, options) {
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const dirName = getDirname(path);
       const baseName = getBasename(path);
       const parentDir = state.fsMap.get(dirName);
@@ -196,13 +202,14 @@ function createNodeishMemoryFs() {
       } else if (options == null ? void 0 : options.recursive) {
         const parent = getDirname(path);
         const parentRes = await mkdir(parent, options);
-        await mkdir(path, options);
+        await mkdir(path, { recursive: false }).catch(() => {
+        });
         return parentRes;
       }
       throw new FilesystemError("ENOENT", path, "mkdir");
     },
     rm: async function rm(path, options) {
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const dirName = getDirname(path);
       const baseName = getBasename(path);
       const target = state.fsMap.get(path);
@@ -241,7 +248,7 @@ function createNodeishMemoryFs() {
      * @throws {"ENOENT" | WatchAbortedError} // TODO: move to lix error classes FileDoesNotExistError
      */
     watch: function(path, options) {
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const watchName = getBasename(path);
       const watchDir = getDirname(path);
       const watchPath = watchName === "/" ? watchDir : watchDir + watchName;
@@ -308,7 +315,7 @@ function createNodeishMemoryFs() {
       return asyncIterator();
     },
     rmdir: async function(path) {
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const dirName = getDirname(path);
       const baseName = getBasename(path);
       const target = state.fsMap.get(path);
@@ -330,9 +337,13 @@ function createNodeishMemoryFs() {
       }
     },
     symlink: async function(target, path) {
-      path = normalPath(path);
-      target = target.startsWith("/") ? target : `${path}/../${target}`;
-      const targetInode = state.fsMap.get(normalPath(target));
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
+      const rawTarget = target.startsWith("/") ? target : `${path}/../${target}`;
+      const targetWithTrailing = normalizePath(rawTarget, {
+        trailingSlash: "always",
+        leadingSlash: "always"
+      });
+      const targetInode = state.fsMap.get(targetWithTrailing);
       const parentDir = state.fsMap.get(getDirname(path));
       if (state.fsMap.get(path)) {
         throw new FilesystemError("EEXIST", path, "symlink", target);
@@ -352,11 +363,11 @@ function createNodeishMemoryFs() {
         stats: state.fsStats,
         kind: 2,
         modeBits: 511,
-        target
+        target: rawTarget
       });
     },
     unlink: async function(path) {
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const targetStats = state.fsStats.get(path);
       const target = state.fsMap.get(path);
       const parentDir = state.fsMap.get(getDirname(path));
@@ -373,7 +384,7 @@ function createNodeishMemoryFs() {
       state.fsMap.delete(path);
     },
     readlink: async function(path) {
-      path = normalPath(path);
+      path = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
       const linkStats = await lstat(path);
       if (linkStats === void 0) {
         throw new FilesystemError("ENOENT", path, "readlink");
@@ -389,9 +400,10 @@ function createNodeishMemoryFs() {
   function newStatEntry({ path, stats, kind, modeBits, target, oid, rootHash }) {
     const currentTime = Date.now();
     const _kind = kind;
-    const oldStats = stats.get(normalPath(path));
+    const targetPath = normalizePath(path, { trailingSlash: "always", leadingSlash: "always" });
+    const oldStats = stats.get(targetPath);
     const mtimeMs = Math.floor(currentTime / 1e3) === ((oldStats == null ? void 0 : oldStats.mtimeMs) && Math.floor((oldStats == null ? void 0 : oldStats.mtimeMs) / 1e3)) ? currentTime + 1e3 : currentTime;
-    stats.set(normalPath(path), {
+    stats.set(targetPath, {
       ctimeMs: (oldStats == null ? void 0 : oldStats.ctimeMs) || currentTime,
       mtimeMs,
       dev: 0,
@@ -415,6 +427,5 @@ export {
   createNodeishMemoryFs,
   getBasename,
   getDirname,
-  normalPath,
-  b as normalizePath
+  normalizePath
 };

package/dist/index.js

@@ -5169,6 +5169,7 @@ const resolveMessageLintRules = (args) => {
     if (value$1.Value.Check(MessageLintRule, rule) === false) {
       const errors2 = [...value$1.Value.Errors(MessageLintRule, rule)];
       result.errors.push(new MessageLintRuleIsInvalidError({
+        // @ts-ignore
         id: rule.id,
         errors: errors2
       }));
@@ -5192,28 +5193,37 @@ async function readModuleFromCache(moduleURI, projectPath, readFile) {
 async function writeModuleToCache(moduleURI, moduleContent, projectPath, writeFile, mkdir) {
   const moduleHash = escape(moduleURI);
   const filePath = projectPath + `/cache/modules/${moduleHash}`;
-  try {
-    await writeFile(filePath, moduleContent);
-  } catch (e) {
-    if (!(e instanceof Error) || !e.message.includes("ENONET"))
-      return;
-    await mkdir(projectPath + `/cache/modules`, { recursive: true });
-    await writeFile(filePath, moduleContent);
+  const writeFileResult = await tryCatch(() => writeFile(filePath, moduleContent));
+  if (writeFileResult.error) {
+    const dirPath = projectPath + `/cache/modules`;
+    const createDirResult = await tryCatch(() => mkdir(dirPath, { recursive: true }));
+    if (createDirResult.error && createDirResult.error.code !== "EEXIST")
+      throw new Error("[sdk:module-cacke] failed to create cache-directory. Path: " + dirPath, {
+        cause: createDirResult.error
+      });
+    const writeFileResult2 = await tryCatch(() => writeFile(filePath, moduleContent));
+    if (writeFileResult2.error)
+      throw new Error("[sdk:module-cacke] failed to write cache-file. Path: " + filePath, {
+        cause: writeFileResult2.error
+      });
   }
 }
 function withCache(moduleLoader, projectPath, nodeishFs) {
   return async (uri) => {
     const cachePromise = readModuleFromCache(uri, projectPath, nodeishFs.readFile);
-    const networkResult = await tryCatch(async () => await moduleLoader(uri));
-    if (networkResult.error) {
+    const loaderResult = await tryCatch(async () => await moduleLoader(uri));
+    if (loaderResult.error) {
       const cacheResult = await cachePromise;
       if (!cacheResult.error)
         return cacheResult.data;
       else
-        throw networkResult.error;
+        throw loaderResult.error;
     } else {
-      const moduleAsText = networkResult.data;
-      await writeModuleToCache(uri, moduleAsText, projectPath, nodeishFs.writeFile, nodeishFs.mkdir);
+      const moduleAsText = loaderResult.data;
+      try {
+        await writeModuleToCache(uri, moduleAsText, projectPath, nodeishFs.writeFile, nodeishFs.mkdir);
+      } catch (error) {
+      }
       return moduleAsText;
     }
   };
@@ -6837,7 +6847,7 @@ function requireNode() {
       return (/* @__PURE__ */ new Date()).toISOString() + " ";
     }
     function log(...args) {
-      return process.stderr.write(util.format(...args) + "\n");
+      return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
     }
     function save(namespaces) {
       if (namespaces) {
@@ -7042,18 +7052,6 @@ function isInlangProjectPath(path) {
 function isAbsolutePath(path) {
   return /^\/|^[A-Za-z]:[\\/]/.test(path);
 }
-async function pathExists$1(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 path exists: ${error}`, { cause: error });
-    }
-  }
-}
 class ProjectSettingsInvalidError extends Error {
   constructor(options) {
     super(`The project settings are invalid:
@@ -7575,54 +7573,58 @@ var ReactiveMap = class extends Map {
   }
 };
 const createNodeishFsWithWatcher = (args) => {
-  const pathList = [];
-  let abortControllers = [];
+  const pathList = /* @__PURE__ */ new Set();
+  const abortControllers = /* @__PURE__ */ new Set();
   const stopWatching = () => {
     for (const ac of abortControllers) {
       ac.abort();
+      abortControllers.delete(ac);
     }
-    abortControllers = [];
   };
-  const makeWatcher = (path) => {
-    (async () => {
-      try {
-        const ac = new AbortController();
-        abortControllers.push(ac);
-        const watcher = args.nodeishFs.watch(path, {
-          signal: ac.signal,
-          persistent: false
-        });
-        if (watcher) {
-          for await (const event of watcher) {
-            args.updateMessages();
-          }
+  const makeWatcher = async (path) => {
+    try {
+      const ac = new AbortController();
+      abortControllers.add(ac);
+      const watcher = args.nodeishFs.watch(path, {
+        signal: ac.signal,
+        recursive: true,
+        persistent: false
+      });
+      if (watcher) {
+        for await (const event of watcher) {
+          args.onChange();
         }
-      } catch (err) {
-        if (err.name === "AbortError")
-          return;
-        else if (err.code === "ENOENT")
-          return;
-        throw err;
       }
-    })();
-  };
-  const readFileAndExtractPath = (path, options) => {
-    if (!pathList.includes(path)) {
-      makeWatcher(path);
-      pathList.push(path);
+    } catch (err) {
+      if (err.name === "AbortError")
+        return;
+      else if (err.code === "ENOENT")
+        return;
+      throw err;
     }
-    return args.nodeishFs.readFile(path, options);
+  };
+  const watched = (fn) => {
+    return (path, ...rest) => {
+      if (!pathList.has(path)) {
+        makeWatcher(path);
+        pathList.add(path);
+      }
+      return fn(path, ...rest);
+    };
   };
   return {
+    ...args.nodeishFs,
+    /**
+     * Reads the file and automatically adds it to the list of watched files.
+     * Any changes to the file will trigger a message update.
+     */
     // @ts-expect-error
-    readFile: (path, options) => readFileAndExtractPath(path, options),
-    rm: args.nodeishFs.rm,
-    readdir: args.nodeishFs.readdir,
-    mkdir: args.nodeishFs.mkdir,
-    rmdir: args.nodeishFs.rmdir,
-    writeFile: args.nodeishFs.writeFile,
-    watch: args.nodeishFs.watch,
-    stat: args.nodeishFs.stat,
+    readFile: watched(args.nodeishFs.readFile),
+    /**
+     * Reads the directory and automatically adds it to the list of watched files.
+     * Any changes to the directory will trigger a message update.
+     */
+    readdir: watched(args.nodeishFs.readdir),
     stopWatching
   };
 };
@@ -7659,53 +7661,36 @@ function normalizeMessage(message) {
 function stringifyMessage(message) {
   return JSON.stringify(normalizeMessage(message), void 0, 4);
 }
-function normalizePath(path, stripTrailing) {
-  if (path === "\\" || path === "/")
+function normalizePath(path, { trailingSlash, leadingSlash } = {}) {
+  path = path.replace(/^\.\//, "/");
+  if (path === "\\" || path === "" || path === "/" || path === "." || path === "//.") {
     return "/";
-  const len = path.length;
-  if (len <= 1)
+  }
+  if (path.length <= 1) {
     return path;
-  let prefix = "";
-  if (len > 4 && path[3] === "\\") {
-    const ch = path[2];
-    if ((ch === "?" || ch === ".") && path.slice(0, 2) === "\\\\") {
-      path = path.slice(2);
-      prefix = "//";
-    }
   }
+  const hadTrailingSlash = path[path.length - 1] === "/" || path[path.length - 1] === "\\";
+  const addleadingSlash = leadingSlash === "always" || path[0] === "/" || path[0] === "\\";
   const segs = path.split(/[/\\]+/);
   const stack = [];
   for (const seg of segs) {
     if (seg === "..") {
       stack.pop();
-    } else if (seg !== ".") {
+    } else if (seg && seg !== ".") {
       stack.push(seg);
     }
   }
-  if (stripTrailing !== false && stack.at(-1) === "") {
-    stack.pop();
+  if (trailingSlash !== "strip" && (hadTrailingSlash || trailingSlash === "always")) {
+    stack.push("");
   }
-  return prefix + stack.join("/");
-}
-const dots = /(\/|^)(\.\/)+/g;
-const slashes = /\/+/g;
-const upreference = /(?<!\.\.)[^/]+\/\.\.\//;
-function normalPath(path) {
-  var _a;
-  path = `/${path}/`;
-  path = path.replace(/^\/\.\./, "");
-  path = path.replace(dots, "/").replace(slashes, "/");
-  let match;
-  while (match = (_a = path.match(upreference)) == null ? void 0 : _a[0]) {
-    path = path.replace(match, "");
-  }
-  return path;
+  return addleadingSlash ? "/" + stack.join("/") : stack.join("/");
 }
 function getDirname(path) {
-  return normalPath(path.split("/").filter((x) => x).slice(0, -1).join("/") ?? path);
+  const dirname = path.split("/").filter((x) => x).slice(0, -1).join("/");
+  return normalizePath(dirname, { leadingSlash: "always", trailingSlash: "always" }) ?? path;
 }
 function getBasename(path) {
-  return path.split("/").filter((x) => x).at(-1) ?? path;
+  return path.split("/").filter((x) => x).at(-1) ?? "";
 }
 const debug$6 = _debug("sdk:fileLock");
 const maxRetries = 10;
@@ -9235,7 +9220,7 @@ function createMessagesQuery({ projectPath, nodeishFs, settings, resolvedModules
       nodeishFs,
       // this message is called whenever a file changes that was read earlier by this filesystem
       // - the plugin loads messages -> reads the file messages.json -> start watching on messages.json -> updateMessages
-      updateMessages: () => {
+      onChange: () => {
         loadMessagesViaPlugin(
           fsWithWatcher,
           messageLockDirPath,
@@ -10015,16 +10000,30 @@ async function maybeAddModuleCache(args) {
   const gitignoreExists = await fileExists(gitignorePath, args.repo.nodeishFs);
   const moduleCacheExists = await directoryExists(moduleCache, args.repo.nodeishFs);
   if (gitignoreExists) {
-    const gitignore = await args.repo.nodeishFs.readFile(gitignorePath, { encoding: "utf-8" });
-    const missingIgnores = EXPECTED_IGNORES.filter((ignore) => !gitignore.includes(ignore));
-    if (missingIgnores.length > 0) {
-      await args.repo.nodeishFs.appendFile(gitignorePath, "\n" + missingIgnores.join("\n"));
+    try {
+      const gitignore = await args.repo.nodeishFs.readFile(gitignorePath, { encoding: "utf-8" });
+      const missingIgnores = EXPECTED_IGNORES.filter((ignore) => !gitignore.includes(ignore));
+      if (missingIgnores.length > 0) {
+        await args.repo.nodeishFs.appendFile(gitignorePath, "\n" + missingIgnores.join("\n"));
+      }
+    } catch (error) {
+      throw new Error("[migrate:module-cache] Failed to update .gitignore", { cause: error });
     }
   } else {
-    await args.repo.nodeishFs.writeFile(gitignorePath, EXPECTED_IGNORES.join("\n"));
+    try {
+      await args.repo.nodeishFs.writeFile(gitignorePath, EXPECTED_IGNORES.join("\n"));
+    } catch (e) {
+      if (e.code && e.code !== "EISDIR" && e.code !== "EEXIST") {
+        throw new Error("[migrate:module-cache] Failed to create .gitignore", { cause: e });
+      }
+    }
   }
   if (!moduleCacheExists) {
-    await args.repo.nodeishFs.mkdir(moduleCache, { recursive: true });
+    try {
+      await args.repo.nodeishFs.mkdir(moduleCache, { recursive: true });
+    } catch (e) {
+      throw new Error("[migrate:module-cache] Failed to create cache directory", { cause: e });
+    }
   }
 }
 async function fileExists(path, nodeishFs) {
@@ -10347,39 +10346,54 @@ async function loadProject(args) {
     const { data: projectId } = await tryCatch(() => nodeishFs.readFile(args.projectPath + "/project_id", { encoding: "utf-8" }));
     const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
     const [loadedSettings, markSettingsAsLoaded, markSettingsAsFailed] = createAwaitable();
+    const [resolvedModules, setResolvedModules] = createSignal();
     const [settings, _setSettings] = createSignal();
     let v2Persistence = false;
     let locales = [];
-    createEffect(() => {
-      loadSettings({ settingsFilePath: projectPath + "/settings.json", nodeishFs }).then((settings2) => {
-        setSettings(settings2);
-        markSettingsAsLoaded();
-      }).catch((err) => {
-        markInitAsFailed(err);
-        markSettingsAsFailed(err);
-      });
-    });
-    const writeSettingsToDisk = skipFirst((settings2) => _writeSettingsToDisk({ nodeishFs, settings: settings2, projectPath }));
-    const setSettings = (settings2) => {
+    const setSettings = (newSettings) => {
       var _a;
       try {
-        const validatedSettings = parseSettings(settings2);
+        const validatedSettings = parseSettings(newSettings);
         v2Persistence = !!((_a = validatedSettings.experimental) == null ? void 0 : _a.persistence);
         locales = validatedSettings.languageTags;
         batch(() => {
           setResolvedModules(void 0);
           _setSettings(validatedSettings);
         });
-        writeSettingsToDisk(validatedSettings);
-        return { data: void 0 };
+        return { data: validatedSettings };
       } catch (error) {
         if (error instanceof ProjectSettingsInvalidError) {
           return { error };
         }
-        throw new Error("Unhandled error in setSettings. This is an internal bug. Please file an issue.");
+        throw new Error("Unhandled error in setSettings. This is an internal bug. Please file an issue.", { cause: error });
       }
     };
-    const [resolvedModules, setResolvedModules] = createSignal();
+    const nodeishFsWithWatchersForSettings = createNodeishFsWithWatcher({
+      nodeishFs,
+      onChange: async () => {
+        const readSettingsResult = await tryCatch(async () => await loadSettings({
+          settingsFilePath: projectPath + "/settings.json",
+          nodeishFs
+        }));
+        if (readSettingsResult.error)
+          return;
+        const newSettings = readSettingsResult.data;
+        if (JSON.stringify(newSettings) !== JSON.stringify(settings())) {
+          setSettings(newSettings);
+        }
+      }
+    });
+    const settingsResult = await tryCatch(async () => await loadSettings({
+      settingsFilePath: projectPath + "/settings.json",
+      nodeishFs: nodeishFsWithWatchersForSettings
+    }));
+    if (settingsResult.error) {
+      markInitAsFailed(settingsResult.error);
+      markSettingsAsFailed(settingsResult.error);
+    } else {
+      setSettings(settingsResult.data);
+      markSettingsAsLoaded();
+    }
     createEffect(() => {
       const _settings = settings();
       if (!_settings)
@@ -10504,7 +10518,12 @@ async function loadProject(args) {
         //...(lintErrors() ?? []),
       ]),
       settings: createSubscribable(() => settings()),
-      setSettings,
+      setSettings: (newSettings) => {
+        const result = setSettings(newSettings);
+        if (!result.error)
+          writeSettingsToDisk({ nodeishFs, settings: result.data, projectPath });
+        return result.error ? result : { data: void 0 };
+      },
       customApi: createSubscribable(() => {
         var _a;
         return ((_a = resolvedModules()) == null ? void 0 : _a.resolvedPluginApi.customApi) || {};
@@ -10559,18 +10578,17 @@ const parseSettings = (settings) => {
   }
   return withMigration;
 };
-const _writeSettingsToDisk = async (args) => {
-  const { data: serializedSettings, error: serializeSettingsError } = tryCatch(() => (
+const writeSettingsToDisk = async (args) => {
+  const serializeResult = tryCatch(() => (
     // TODO: this will probably not match the original formatting
     JSON.stringify(args.settings, void 0, 2)
   ));
-  if (serializeSettingsError) {
-    throw serializeSettingsError;
-  }
-  const { error: writeSettingsError } = await tryCatch(async () => args.nodeishFs.writeFile(args.projectPath + "/settings.json", serializedSettings));
-  if (writeSettingsError) {
-    throw writeSettingsError;
-  }
+  if (serializeResult.error)
+    throw serializeResult.error;
+  const serializedSettings = serializeResult.data;
+  const writeResult = await tryCatch(async () => await args.nodeishFs.writeFile(args.projectPath + "/settings.json", serializedSettings));
+  if (writeResult.error)
+    throw writeResult.error;
 };
 const createAwaitable = () => {
   let resolve;
@@ -10581,15 +10599,6 @@ const createAwaitable = () => {
   });
   return [promise, resolve, reject];
 };
-function skipFirst(func) {
-  let initial = false;
-  return function(...args) {
-    if (initial) {
-      return func.apply(this, args);
-    }
-    initial = true;
-  };
-}
 function createSubscribable(signal) {
   return Object.assign(signal, {
     subscribe: (callback) => {
@@ -11349,24 +11358,22 @@ function split(array, predicate) {
 export {
   Logger,
   getBasename as a,
-  normalizePath as b,
-  assertValidProjectPath as c,
+  assertValidProjectPath as b,
+  getDefaultExportFromCjs as c,
   classifyProjectErrors,
   compile,
-  pathExists$1 as d,
-  getDefaultExportFromCjs as e,
-  parseOrigin as f,
+  parseOrigin as d,
+  commonjsGlobal as e,
+  getAugmentedNamespace as f,
   getDirname as g,
-  commonjsGlobal as h,
-  getAugmentedNamespace as i,
-  parseLixUri as j,
-  typebox as k,
+  parseLixUri as h,
+  typebox as i,
+  telemetry as j,
+  pathExists as k,
   loadProject as l,
-  telemetry as m,
-  normalPath as n,
-  pathExists as o,
+  findPackageJson as m,
+  normalizePath as n,
   pattern$1 as p,
-  findPackageJson as q,
   transformRemote as t,
   value$1 as v,
   withProxy as w,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -57,18 +57,18 @@
     "@vitest/coverage-v8": "0.34.3",
     "memfs": "4.6.0",
     "rollup": "3.29.1",
-    "typescript": "5.2.2",
+    "typescript": "^5.5.2",
     "vite": "4.5.2",
     "vite-plugin-dts": "^3.8.1",
     "vite-tsconfig-paths": "^4.3.2",
     "vitest": "0.34.3",
-    "@inlang/cross-sell-sherlock": "0.0.4",
-    "@inlang/cross-sell-ninja": "0.0.33",
-    "@inlang/language-tag": "1.5.1",
-    "@inlang/sdk": "0.36.1",
-    "@lix-js/client": "2.2.0",
+    "@inlang/recommend-sherlock": "0.1.0",
+    "@inlang/recommend-ninja": "0.1.0",
     "@inlang/plugin-message-format": "2.2.0",
-    "@lix-js/fs": "2.1.0"
+    "@inlang/sdk": "0.36.3",
+    "@inlang/language-tag": "1.5.1",
+    "@lix-js/client": "2.2.1",
+    "@lix-js/fs": "2.2.0"
   },
   "exports": {
     ".": {