@inlang/paraglide-js 2.4.0 → 2.5.0

package/dist/bundler-plugins/vite.d.ts

@@ -1,2 +1,2 @@
-export declare const paraglideVitePlugin: (options: import("../index.js").CompilerOptions) => import("vite").Plugin<any> | import("vite").Plugin<any>[];
+export declare const paraglideVitePlugin: (options: import("../index.js").CompilerOptions) => import("unplugin").VitePlugin<any> | import("unplugin").VitePlugin<any>[];
 //# sourceMappingURL=vite.d.ts.map

package/dist/bundler-plugins/vite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/vite.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,+GAAoC,CAAC"}
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/vite.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,+HAAoC,CAAC"}

package/dist/cli/steps/update-ts-config.d.ts

@@ -11,4 +11,17 @@ export declare const maybeUpdateTsConfigAllowJs: CliStep<{
     fs: typeof import("node:fs/promises");
     logger: Logger;
 }, unknown>;
+/**
+ * Recursively checks whether allowJs is enabled in the provided tsconfig or any
+ * referenced configuration files.
+ *
+ * @param tsconfigPath The path to the tsconfig to inspect.
+ * @param fs The file system used to read the configs.
+ * @param visited A set of already inspected files to avoid circular lookups.
+ * @example
+ * ```ts
+ * await hasAllowJsEnabled("./tsconfig.json", fs);
+ * ```
+ */
+export declare const hasAllowJsEnabled: (tsconfigPath: string, fs: typeof import("node:fs/promises"), visited?: Set<string>) => Promise<boolean>;
 //# sourceMappingURL=update-ts-config.d.ts.map

package/dist/cli/steps/update-ts-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-ts-config.d.ts","sourceRoot":"","sources":["../../../src/cli/steps/update-ts-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAM7D,eAAO,MAAM,mBAAmB,EAAE,OAAO,CACxC;IAAE,EAAE,EAAE,cAAc,kBAAkB,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzD,OAAO,CAKP,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,OAAO,CAC/C;IAAE,EAAE,EAAE,cAAc,kBAAkB,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzD,OAAO,CA4DP,CAAC"}
+{"version":3,"file":"update-ts-config.d.ts","sourceRoot":"","sources":["../../../src/cli/steps/update-ts-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAS7D,eAAO,MAAM,mBAAmB,EAAE,OAAO,CACxC;IAAE,EAAE,EAAE,cAAc,kBAAkB,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzD,OAAO,CAKP,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,OAAO,CAC/C;IAAE,EAAE,EAAE,cAAc,kBAAkB,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzD,OAAO,CA6CP,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,GAC7B,cAAc,MAAM,EACpB,IAAI,cAAc,kBAAkB,CAAC,EACrC,UAAS,GAAG,CAAC,MAAM,CAAa,KAC9B,OAAO,CAAC,OAAO,CA4CjB,CAAC"}

package/dist/cli/steps/update-ts-config.js

@@ -1,7 +1,9 @@
 import { prompt } from "../utils.js";
 import JSON5 from "json5";
 import { pathExists } from "../../services/file-handling/exists.js";
-// import nodePath from "node:path";
+import nodePath from "node:path";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
 export const maybeUpdateTsConfig = async (ctx) => {
     const ctx1 = await maybeUpdateTsConfigAllowJs(ctx);
     return ctx1;
@@ -14,10 +16,7 @@ export const maybeUpdateTsConfigAllowJs = async (ctx) => {
     if ((await pathExists("./tsconfig.json", ctx.fs)) === false) {
         return ctx;
     }
-    const file = await ctx.fs.readFile("./tsconfig.json", { encoding: "utf-8" });
-    // tsconfig allows comments ... FML
-    let tsconfig = JSON5.parse(file);
-    if (tsconfig.compilerOptions?.allowJs === true) {
+    if (await hasAllowJsEnabled("./tsconfig.json", ctx.fs)) {
         // all clear, allowJs is already set to true
         return ctx;
     }
@@ -38,17 +37,7 @@ export const maybeUpdateTsConfigAllowJs = async (ctx) => {
             ctx.logger.warn("Continuing without adjusting the tsconfig.json. This may lead to type errors.");
             return ctx;
         }
-        // don't re-ask the question if there is an `extends` present in the tsconfig
-        // just trust that it's correct.
-        if (tsconfig.extends) {
-            isValid = true;
-            return ctx;
-        }
-        const file = await ctx.fs.readFile("./tsconfig.json", {
-            encoding: "utf-8",
-        });
-        tsconfig = JSON5.parse(file);
-        if (tsconfig?.compilerOptions?.allowJs === true) {
+        if (await hasAllowJsEnabled("./tsconfig.json", ctx.fs)) {
             isValid = true;
             return ctx;
         }
@@ -58,6 +47,132 @@ export const maybeUpdateTsConfigAllowJs = async (ctx) => {
     }
     return ctx;
 };
+/**
+ * Recursively checks whether allowJs is enabled in the provided tsconfig or any
+ * referenced configuration files.
+ *
+ * @param tsconfigPath The path to the tsconfig to inspect.
+ * @param fs The file system used to read the configs.
+ * @param visited A set of already inspected files to avoid circular lookups.
+ * @example
+ * ```ts
+ * await hasAllowJsEnabled("./tsconfig.json", fs);
+ * ```
+ */
+export const hasAllowJsEnabled = async (tsconfigPath, fs, visited = new Set()) => {
+    const normalizedPath = normalizeConfigPath(tsconfigPath);
+    if (visited.has(normalizedPath)) {
+        return false;
+    }
+    visited.add(normalizedPath);
+    const file = await fs.readFile(normalizedPath, { encoding: "utf-8" });
+    const tsconfig = JSON5.parse(file);
+    if (tsconfig?.compilerOptions?.allowJs === true) {
+        return true;
+    }
+    const baseDir = nodePath.dirname(normalizedPath);
+    const extendCandidates = Array.isArray(tsconfig?.extends)
+        ? tsconfig.extends
+        : tsconfig?.extends
+            ? [tsconfig.extends]
+            : [];
+    for (const candidate of extendCandidates) {
+        if (typeof candidate !== "string")
+            continue;
+        const resolved = await resolveExtendedConfig(candidate, baseDir, fs);
+        if (resolved && (await hasAllowJsEnabled(resolved, fs, visited))) {
+            return true;
+        }
+    }
+    if (Array.isArray(tsconfig?.references)) {
+        for (const reference of tsconfig.references) {
+            const referencePath = reference?.path;
+            if (typeof referencePath !== "string")
+                continue;
+            const resolved = await resolveReferenceConfig(referencePath, baseDir, fs);
+            if (resolved && (await hasAllowJsEnabled(resolved, fs, visited))) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+/**
+ * Normalizes a tsconfig path to an absolute path.
+ */
+const normalizeConfigPath = (configPath) => {
+    return nodePath.isAbsolute(configPath)
+        ? configPath
+        : nodePath.resolve(process.cwd(), configPath);
+};
+/**
+ * Resolves the extended tsconfig path relative to the base config.
+ */
+const resolveExtendedConfig = async (extendsSpecifier, baseDir, fs) => {
+    const candidates = new Set();
+    const resolvedBase = nodePath.isAbsolute(extendsSpecifier)
+        ? extendsSpecifier
+        : nodePath.resolve(baseDir, extendsSpecifier);
+    candidates.add(resolvedBase);
+    if (nodePath.extname(resolvedBase) === "") {
+        candidates.add(`${resolvedBase}.json`);
+        candidates.add(nodePath.join(resolvedBase, "tsconfig.json"));
+    }
+    for (const candidate of candidates) {
+        if (await pathExists(candidate, fs)) {
+            return candidate;
+        }
+    }
+    try {
+        return require.resolve(extendsSpecifier, { paths: [baseDir] });
+    }
+    catch {
+        if (extendsSpecifier.endsWith(".json") === false) {
+            try {
+                return require.resolve(`${extendsSpecifier}.json`, {
+                    paths: [baseDir],
+                });
+            }
+            catch {
+                return undefined;
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * Resolves the tsconfig referenced through the `references` property.
+ */
+const resolveReferenceConfig = async (referenceSpecifier, baseDir, fs) => {
+    const candidates = new Set();
+    const resolvedBase = nodePath.isAbsolute(referenceSpecifier)
+        ? referenceSpecifier
+        : nodePath.resolve(baseDir, referenceSpecifier);
+    candidates.add(resolvedBase);
+    if (nodePath.extname(resolvedBase) === "") {
+        candidates.add(`${resolvedBase}.json`);
+        candidates.add(nodePath.join(resolvedBase, "tsconfig.json"));
+    }
+    for (const candidate of candidates) {
+        if (await pathExists(candidate, fs)) {
+            try {
+                const stats = await fs.stat(candidate);
+                if (stats.isDirectory()) {
+                    const directoryConfig = nodePath.join(candidate, "tsconfig.json");
+                    if (await pathExists(directoryConfig, fs)) {
+                        return directoryConfig;
+                    }
+                    continue;
+                }
+            }
+            catch {
+                // ignore, we'll continue checking other candidates
+            }
+            return candidate;
+        }
+    }
+    return undefined;
+};
 // /**
 //  * Ensures that the moduleResolution compiler option is set to "bundler" or similar in the tsconfig.json.
 //  *

package/dist/cli/steps/update-ts-config.test.d.ts

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

package/dist/cli/steps/update-ts-config.test.d.ts.map

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

package/dist/cli/steps/update-ts-config.test.js

@@ -0,0 +1,59 @@
+import { expect, test, vi } from "vitest";
+import { memfs } from "memfs";
+import { maybeUpdateTsConfigAllowJs } from "./update-ts-config.js";
+import { Logger } from "../../services/logger/index.js";
+const setCwd = (cwd) => {
+    const original = process.cwd;
+    process.cwd = (() => cwd);
+    return () => {
+        process.cwd = original;
+    };
+};
+// Regression coverage for https://github.com/opral/inlang-paraglide-js/issues/560
+test("skips prompting when allowJs is set in a referenced tsconfig", async () => {
+    const fs = memfs({
+        "/tsconfig.json": JSON.stringify({
+            references: [{ path: "./tsconfig.app.json" }],
+        }),
+        "/tsconfig.app.json": JSON.stringify({
+            compilerOptions: { allowJs: true },
+        }),
+    }).fs;
+    const restoreCwd = setCwd("/");
+    const logger = new Logger({ silent: true, prefix: false });
+    const infoSpy = vi.spyOn(logger, "info");
+    try {
+        await maybeUpdateTsConfigAllowJs({
+            fs: fs.promises,
+            logger,
+        });
+        expect(infoSpy).not.toHaveBeenCalled();
+    }
+    finally {
+        restoreCwd();
+    }
+});
+// Regression coverage for https://github.com/opral/inlang-paraglide-js/issues/560
+test("skips prompting when allowJs is provided via extends", async () => {
+    const fs = memfs({
+        "/tsconfig.json": JSON.stringify({
+            extends: "./tsconfig.base.json",
+        }),
+        "/tsconfig.base.json": JSON.stringify({
+            compilerOptions: { allowJs: true },
+        }),
+    }).fs;
+    const restoreCwd = setCwd("/");
+    const logger = new Logger({ silent: true, prefix: false });
+    const infoSpy = vi.spyOn(logger, "info");
+    try {
+        await maybeUpdateTsConfigAllowJs({
+            fs: fs.promises,
+            logger,
+        });
+        expect(infoSpy).not.toHaveBeenCalled();
+    }
+    finally {
+        restoreCwd();
+    }
+});

package/dist/compiler/output-file.d.ts

@@ -0,0 +1,6 @@
+export type OutputFile = {
+    filename: string;
+    contents: string;
+};
+export type EmitOutputFile = (file: OutputFile) => void | Promise<void>;
+//# sourceMappingURL=output-file.d.ts.map

package/dist/compiler/output-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-file.d.ts","sourceRoot":"","sources":["../../src/compiler/output-file.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC"}

package/dist/compiler/output-file.js

@@ -0,0 +1 @@
+export {};

package/dist/compiler/output-structure/message-modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message-modules.d.ts","sourceRoot":"","sources":["../../../src/compiler/output-structure/message-modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAKvE,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,UAE1E;AAED,wBAAgB,cAAc,CAC7B,eAAe,EAAE,0BAA0B,EAAE,EAC7C,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,YAAY,CAAC,EACzD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAC7C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkFxB"}
+{"version":3,"file":"message-modules.d.ts","sourceRoot":"","sources":["../../../src/compiler/output-structure/message-modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAKvE,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,UAE1E;AAED,wBAAgB,cAAc,CAC7B,eAAe,EAAE,0BAA0B,EAAE,EAC7C,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,SAAS,GAAG,YAAY,CAAC,EACzD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAC7C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA+GxB"}

package/dist/compiler/output-structure/message-modules.js

@@ -31,19 +31,41 @@ export function generateOutput(compiledBundles, settings, fallbackMap) {
         }
         // add the fallbacks (needs to be done after the messages to avoid referencing
         // the message before they are defined)
-        for (const locale of needsFallback) {
-            // add fallback
+        const needsFallbackSet = new Set(needsFallback);
+        const emittedFallbacks = new Set();
+        const emittingFallbacks = new Set();
+        /**
+         * Emits the fallback definition for a locale ensuring that dependent fallbacks
+         * are declared beforehand.
+         *
+         * @example
+         * emitFallback("fr-ca");
+         */
+        const emitFallback = (locale) => {
+            if (emittedFallbacks.has(locale))
+                return;
+            if (emittingFallbacks.has(locale))
+                return;
+            emittingFallbacks.add(locale);
             const safeLocale = toSafeModuleId(locale);
             const fallbackLocale = fallbackMap[locale];
+            if (fallbackLocale &&
+                needsFallbackSet.has(fallbackLocale) &&
+                !compiledBundle.messages[fallbackLocale]) {
+                emitFallback(fallbackLocale);
+            }
             if (fallbackLocale) {
                 const safeFallbackLocale = toSafeModuleId(fallbackLocale);
-                // take the fallback locale
                 messages.push(`/** @type {(inputs: ${inputsType(inputs)}) => string} */\nconst ${safeLocale}_${safeModuleId} = ${safeFallbackLocale}_${safeModuleId};`);
             }
             else {
-                // fallback to just the bundle id
                 messages.push(`/** @type {(inputs: ${inputsType(inputs)}) => string} */\nconst ${safeLocale}_${safeModuleId} = () => '${escapeForSingleQuoteString(bundleId)}'`);
             }
+            emittingFallbacks.delete(locale);
+            emittedFallbacks.add(locale);
+        };
+        for (const locale of needsFallback) {
+            emitFallback(locale);
         }
         output[filename] = messages.join("\n\n") + "\n\n" + output[filename];
         // add the imports

package/dist/compiler/output-structure/message-modules.test.js

@@ -75,3 +75,45 @@ test("handles case senstivity by creating directories and files only in lowercas
     expect(output).toHaveProperty("messages/happyelephant2.js");
     expect(output).not.toHaveProperty("messages/HappyElephant.js");
 });
+// Regression test for https://github.com/opral/inlang-paraglide-js/issues/507
+test("emits fallback definitions after their dependencies", () => {
+    const resources = [
+        {
+            bundle: {
+                code: "export const admin_tasks = (inputs) => inputs;",
+                node: {
+                    id: "admin_tasks",
+                    declarations: [],
+                },
+            },
+            messages: {
+                en: {
+                    code: '/** @type {(inputs: {}) => string} */ () => "admin"',
+                    node: {},
+                },
+            },
+        },
+    ];
+    const settings = {
+        locales: ["fr-ca", "fr", "en"],
+        baseLocale: "en",
+    };
+    const fallbackMap = {
+        "fr-ca": "fr",
+        fr: "en",
+        en: undefined,
+    };
+    const output = generateOutput(resources, settings, fallbackMap);
+    const file = output["messages/admin_tasks.js"];
+    expect(file).toBeDefined();
+    if (!file) {
+        throw new Error("messages/admin_tasks.js should have been generated");
+    }
+    expect(file).toContain("const fr_admin_tasks = en_admin_tasks;");
+    expect(file).toContain("const fr_ca_admin_tasks = fr_admin_tasks;");
+    const frIndex = file.indexOf("const fr_admin_tasks");
+    const frCaIndex = file.indexOf("const fr_ca_admin_tasks");
+    expect(frIndex).toBeGreaterThan(-1);
+    expect(frCaIndex).toBeGreaterThan(-1);
+    expect(frIndex).toBeLessThan(frCaIndex);
+});

package/dist/compiler/runtime/assert-is-locale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert-is-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/assert-is-locale.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,sCAJW,GAAG,GACD,MAAM,CAUlB"}
+{"version":3,"file":"assert-is-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/assert-is-locale.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,sCAJW,GAAG,GACD,MAAM,CAiBlB"}

package/dist/compiler/runtime/assert-is-locale.js

@@ -1,4 +1,3 @@
-import { isLocale } from "./is-locale.js";
 import { locales } from "./variables.js";
 /**
  * Asserts that the input is a locale.
@@ -8,8 +7,13 @@ import { locales } from "./variables.js";
  * @throws {Error} If the input is not a locale.
  */
 export function assertIsLocale(input) {
-    if (isLocale(input) === false) {
+    if (typeof input !== "string") {
+        throw new Error(`Invalid locale: ${input}. Expected a string.`);
+    }
+    const lowerInput = input.toLowerCase();
+    const matchedLocale = locales.find((item) => item.toLowerCase() === lowerInput);
+    if (!matchedLocale) {
         throw new Error(`Invalid locale: ${input}. Expected one of: ${locales.join(", ")}`);
     }
-    return input;
+    return matchedLocale;
 }

package/dist/compiler/runtime/assert-is-locale.test.js

@@ -1,6 +1,6 @@
-import { test, expect } from "vitest";
-import { createParaglide } from "../create-paraglide.js";
 import { newProject } from "@inlang/sdk";
+import { expect, test } from "vitest";
+import { createParaglide } from "../create-paraglide.js";
 test("throws if the locale is not available", async () => {
     const runtime = await createParaglide({
         blob: await newProject({
@@ -12,6 +12,21 @@ test("throws if the locale is not available", async () => {
     });
     expect(() => runtime.assertIsLocale("es")).toThrow();
 });
+test("throws for non-string inputs", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "de"],
+            },
+        }),
+    });
+    expect(() => runtime.assertIsLocale(null)).toThrow();
+    expect(() => runtime.assertIsLocale(undefined)).toThrow();
+    expect(() => runtime.assertIsLocale(123)).toThrow();
+    expect(() => runtime.assertIsLocale({})).toThrow();
+    expect(() => runtime.assertIsLocale([])).toThrow();
+});
 test("passes if the locale is available", async () => {
     const runtime = await createParaglide({
         blob: await newProject({
@@ -37,3 +52,19 @@ test("the return value is a Locale", async () => {
     // in the ambient type definition
     locale;
 });
+test("is case-insensitive", async () => {
+    const runtime = await createParaglide({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "pt-BR", "de-ch"],
+            },
+        }),
+    });
+    expect(() => runtime.assertIsLocale("EN")).not.toThrow();
+    expect(() => runtime.assertIsLocale("pt-br")).not.toThrow();
+    expect(() => runtime.assertIsLocale("de-CH")).not.toThrow();
+    expect(runtime.assertIsLocale("EN")).toBe("en");
+    expect(runtime.assertIsLocale("pT-bR")).toBe("pt-BR");
+    expect(runtime.assertIsLocale("de-CH")).toBe("de-ch");
+});

package/dist/compiler/runtime/is-locale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/is-locale.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,iCAHW,GAAG,GACD,MAAM,IAAI,MAAM,CAI5B"}
+{"version":3,"file":"is-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/is-locale.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,iCAHW,GAAG,GACD,MAAM,IAAI,MAAM,CAO5B"}

package/dist/compiler/runtime/is-locale.js

@@ -13,5 +13,9 @@ import { locales } from "./variables.js";
  * @returns {locale is Locale}
  */
 export function isLocale(locale) {
-    return !locale ? false : locales.includes(locale);
+    if (typeof locale !== "string")
+        return false;
+    return !locale
+        ? false
+        : locales.some((item) => item.toLowerCase() === locale.toLowerCase());
 }

package/dist/compiler/runtime/is-locale.test.d.ts

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

package/dist/compiler/runtime/is-locale.test.d.ts.map

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

package/dist/compiler/runtime/is-locale.test.js

@@ -0,0 +1,31 @@
+import { newProject } from "@inlang/sdk";
+import { expect, test } from "vitest";
+import { createParaglide } from "../create-paraglide.js";
+const runtime = await createParaglide({
+    blob: await newProject({
+        settings: {
+            baseLocale: "en",
+            locales: ["en", "pt-BR", "de-ch"],
+        },
+    }),
+});
+test("returns true for exact matches", () => {
+    expect(runtime.isLocale("pt-BR")).toBe(true);
+});
+test("is case-insensitive", () => {
+    expect(runtime.isLocale("EN")).toBe(true);
+    expect(runtime.isLocale("pt-br")).toBe(true);
+    expect(runtime.isLocale("de-CH")).toBe(true);
+});
+test("returns false for non-existent locales", () => {
+    expect(runtime.isLocale("es")).toBe(false);
+    expect(runtime.isLocale("xx")).toBe(false);
+    expect(runtime.isLocale("")).toBe(false);
+});
+test("returns false for non-string inputs", () => {
+    expect(runtime.isLocale(null)).toBe(false);
+    expect(runtime.isLocale(undefined)).toBe(false);
+    expect(runtime.isLocale(123)).toBe(false);
+    expect(runtime.isLocale({})).toBe(false);
+    expect(runtime.isLocale([])).toBe(false);
+});

package/dist/services/env-variables/index.js

@@ -1,5 +1,5 @@
 export const ENV_VARIABLES = {
     PARJS_APP_ID: "library.inlang.paraglideJs",
     PARJS_POSTHOG_TOKEN: undefined,
-    PARJS_PACKAGE_VERSION: "2.4.0",
+    PARJS_PACKAGE_VERSION: "2.5.0",
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -26,13 +26,13 @@
     "./urlpattern-polyfill": "./dist/urlpattern-polyfill/index.js"
   },
   "dependencies": {
-    "@inlang/sdk": "2.4.9",
     "commander": "11.1.0",
     "consola": "3.4.0",
     "json5": "2.2.3",
     "unplugin": "^2.1.2",
     "urlpattern-polyfill": "^10.0.0",
-    "@inlang/recommend-sherlock": "0.2.1"
+    "@inlang/recommend-sherlock": "0.2.1",
+    "@inlang/sdk": "2.4.9"
   },
   "devDependencies": {
     "@rollup/plugin-virtual": "3.0.2",
@@ -48,8 +48,8 @@
     "typedoc-plugin-missing-exports": "4.0.0",
     "typescript": "5.8.3",
     "vitest": "3.1.4",
-    "@inlang/plugin-message-format": "4.0.0",
-    "@opral/tsconfig": "1.1.0"
+    "@opral/tsconfig": "1.1.0",
+    "@inlang/plugin-message-format": "4.0.0"
   },
   "keywords": [
     "inlang",