@inlang/paraglide-js 2.0.0-beta.15 → 2.0.0-beta.17

package/dist/compiler/runtime/pathname-pattern.test.js

@@ -0,0 +1,103 @@
+import { expect, test } from "vitest";
+import { createRuntimeForTesting } from "./create-runtime.js";
+import { match as pathToRegexp } from "path-to-regexp";
+import { matchPathnamePattern2 } from "./pathname-pattern.js";
+test("1234", async () => {
+    expect(matchPathnamePattern2("/*", "/en")).toBeDefined();
+    expect(matchPathnamePattern2("/*", "/en/hello-world")).toBeDefined();
+    expect(matchPathnamePattern2("/*", "/de/hello-world")).toBeDefined();
+    expect(matchPathnamePattern2("/de*", "/de/hello-world")).toBeDefined();
+    expect(matchPathnamePattern2("/de*", "/de")).toBeDefined();
+});
+test("static pattern", async () => {
+    const { matchPathnamePattern } = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+    });
+    // static pattern
+    expect(pathToRegexp("/about")("/about")).toMatchObject(matchPathnamePattern("/about", "/about"));
+    // static pattern with trailing slash
+    expect(pathToRegexp("/about")("/about/")).toMatchObject(matchPathnamePattern("/about", "/about/"));
+    // static pattern with suffix
+    expect(pathToRegexp("/about/suffix")("/about/suffix")).toMatchObject(matchPathnamePattern("/about/suffix", "/about/suffix"));
+    // both don't match because suffix has leading suffix (peter)
+    expect([
+        matchPathnamePattern("/about/suffix", "/about/suffix/peter"),
+        pathToRegexp("/about/suffix")("/about/suffix/peter"),
+    ]).toStrictEqual([undefined, false]);
+});
+test("wildcard pattern", async () => {
+    const { matchPathnamePattern } = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+    });
+    // wildcard pattern
+    expect(pathToRegexp("/*path")("/about")).toMatchObject(matchPathnamePattern("/*path", "/about"));
+    // wildcard with suffix
+    expect(pathToRegexp("/*path/suffix")("/about/xyz/suffix")).toMatchObject(matchPathnamePattern("/*path/suffix", "/about/xyz/suffix"));
+    // both don't match because suffix has leading suffix (peter)
+    expect([
+        matchPathnamePattern("/*path/suffix", "/about/xyz/suffix/peter"),
+        pathToRegexp("/*path/suffix")("/about/xyz/suffix/peter"),
+    ]).toStrictEqual([undefined, false]);
+});
+test("parameter pattern", async () => {
+    const { matchPathnamePattern } = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+    });
+    // parameter pattern
+    expect(pathToRegexp("/:post")("/123")).toMatchObject(matchPathnamePattern("/:post", "/123"));
+    // parameter pattern with trailing slash
+    expect(pathToRegexp("/:post")("/123/")).toMatchObject(matchPathnamePattern("/:post", "/123/"));
+    // parameter with suffix
+    expect(matchPathnamePattern("/:post/suffix", "/123/suffix")).toMatchObject(matchPathnamePattern("/:post", "/123"));
+});
+test("optional parameter pattern", async () => {
+    const { matchPathnamePattern } = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+    });
+    expect(pathToRegexp("/users{/:id}/delete")("/users/delete")).toMatchObject(matchPathnamePattern("/users{/:id}/delete", "/users/delete"));
+    expect(pathToRegexp("/users{/:id}/delete")("/users/123/delete")).toMatchObject(matchPathnamePattern("/users{/:id}/delete", "/users/123/delete"));
+});
+test("wildcard on root with prefixed slash", async () => {
+    const { matchPathnamePattern } = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+    });
+    expect([
+        matchPathnamePattern("/*path", "/"),
+        pathToRegexp("/*path")("/"),
+    ]).toStrictEqual([undefined, false]);
+});
+test("wildcard on root with no slash", async () => {
+    const { matchPathnamePattern } = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+    });
+    expect(pathToRegexp("*path")("/")).toMatchObject(matchPathnamePattern("*path", "/"));
+});
+test("optional wildcard", async () => {
+    const { matchPathnamePattern } = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+    });
+    expect(pathToRegexp("/{*path}")("/")).toMatchObject(matchPathnamePattern("/{*path}", "/"));
+    expect(pathToRegexp("/de{/*path}")("/de")).toMatchObject(matchPathnamePattern("/de{/*path}", "/de"));
+    expect(pathToRegexp("/de{/*path}")("/de/etwas")).toMatchObject(matchPathnamePattern("/de{/*path}", "/de/etwas"));
+});
+test("generating paths from patterns", async () => {
+    const { compilePathnamePattern } = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en"],
+    });
+    expect(compilePathnamePattern("/:post", { post: "123" })).toBe("/123");
+    expect(compilePathnamePattern("/:category/:id", { category: "books", id: "42" })).toBe("/books/42");
+    expect(compilePathnamePattern("/users{/:id}/delete", { id: "123" })).toBe("/users/123/delete");
+    expect(compilePathnamePattern("/users{/:id}/delete", {})).toBe("/users/delete");
+    expect(compilePathnamePattern("/*path/suffix", { path: ["about", "xyz"] })).toBe("/about/xyz/suffix");
+    expect(compilePathnamePattern("/*path", { path: ["home"] })).toBe("/home");
+    expect(() => compilePathnamePattern("/:post", {})).toThrow('Missing value for parameter ":post"');
+    expect(() => compilePathnamePattern("/*path", { path: "home" })).toThrow('Wildcard parameter "*path" must be an array');
+});

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

@@ -1 +1 @@
-{"version":3,"file":"set-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/set-locale.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,sBAFU,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAoDnC"}
+{"version":3,"file":"set-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/set-locale.js"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,sBAFU,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAuDnC"}

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

@@ -1,6 +1,5 @@
-import { cookieName } from "./cookie-name.js";
+import { cookieName, strategy, TREE_SHAKE_COOKIE_STRATEGY_USED, TREE_SHAKE_PATHNAME_STRATEGY_USED, TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED, } from "./variables.js";
 import { localizePath } from "./localize-path.js";
-import { strategy } from "./strategy.js";
 /**
  * Set the locale.
  *
@@ -12,13 +11,14 @@ import { strategy } from "./strategy.js";
 export let setLocale = (newLocale) => {
     let localeHasBeenSet = false;
     for (const strat of strategy) {
-        if (strat === "variable") {
+        if (TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED &&
+            strat === "globalVariable") {
             // a default for a custom strategy to get started quickly
             // is likely overwritten by `defineSetLocale()`
             _locale = newLocale;
             localeHasBeenSet = true;
         }
-        else if (strat === "cookie") {
+        else if (TREE_SHAKE_COOKIE_STRATEGY_USED && strat === "cookie") {
             if (typeof document === "undefined" || !document.cookie) {
                 continue;
             }
@@ -26,7 +26,7 @@ export let setLocale = (newLocale) => {
             document.cookie = `${cookieName}=${newLocale}`;
             localeHasBeenSet = true;
         }
-        else if (strat === "pathname") {
+        else if (TREE_SHAKE_PATHNAME_STRATEGY_USED && strat === "pathname") {
             if (typeof window === "undefined" || !window.location) {
                 continue;
             }

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

@@ -33,7 +33,7 @@ test("doesn't throw for server unavailable APIs", async () => {
         locales: ["en", "de"],
         compilerOptions: {
             // using browser based strategies first, then variable which is available on the server
-            strategy: ["pathname", "cookie", "variable", "baseLocale"],
+            strategy: ["pathname", "cookie", "globalVariable", "baseLocale"],
         },
     });
     expect(() => runtime.setLocale("de")).not.toThrow();

package/dist/compiler/runtime/ts-runtime.d.ts

@@ -0,0 +1,2 @@
+export declare const tsRuntime = "\n// @eslint-disable\n\n/**\n * The project's base locale.\n *\n * @example\n *   if (locale === baseLocale) {\n *     // do something\n *   }\n */\nexport const baseLocale = \"<replace>\";\n\n/**\n * The project's locales that have been specified in the settings.\n *\n * @example\n *   if (locales.includes(userSelectedLocale) === false) {\n *     throw new Error('Locale is not available');\n *   }\n */\nexport const locales = [\"<replace>\"] as const;\n\n/**\n * This is a default implementation that is almost always\n * overwritten by `defineGetLocale()` and `defineSetLocale()`.\n *\n */\nlet _locale: Locale = baseLocale;\n\n/**\n * Define the `getLocale()` function.\n *\n * Use this function to define how the locale is resolved. For example,\n * you can resolve the locale from the browser's preferred language,\n * a cookie, env variable, or a user's preference.\n *\n * @example\n *   defineGetLocale(() => {\n *     // resolve the locale from a cookie. fallback to the base locale.\n *     return Cookies.get('locale') ?? baseLocale\n *   }\n *\n */\nexport const defineGetLocale: (fn: () => Locale) => void = (fn) => {\n\tgetLocale = fn;\n};\n\n/**\n * Define the `setLocale()` function.\n *\n * Use this function to define how the locale is set. For example,\n * modify a cookie, env variable, or a user's preference.\n *\n * @example\n *   defineSetLocale((newLocale) => {\n *     // set the locale in a cookie\n *     return Cookies.set('locale', newLocale)\n *   });\n *\n */\nexport const defineSetLocale: (fn: (newLocale: Locale) => void) => void = (\n\tfn\n) => {\n\tsetLocale = fn;\n};\n\n/**\n * Get the current locale.\n *\n * @example\n *   if (getLocale() === 'de') {\n *     console.log('Germany \uD83C\uDDE9\uD83C\uDDEA');\n *   } else if (getLocale() === 'nl') {\n *     console.log('Netherlands \uD83C\uDDF3\uD83C\uDDF1');\n *   }\n *\n */\nexport let getLocale: () => Locale =\n\t/** default implementation likely overwritten by `defineGetLocale()` */ () =>\n\t\t_locale;\n\n/**\n * Set the locale.\n *\n * @example\n *   setLocale('en');\n */\nexport let setLocale: (newLocale: Locale) => void = (newLocale) => {\n\t/** default implementation likely overwritten by `defineSetLocale()` */\n\t_locale = newLocale;\n};\n\n/**\n * Check if something is an available locale.\n *\n * @example\n *   if (isLocale(params.locale)) {\n *     setLocale(params.locale);\n *   } else {\n *     setLocale('en');\n *   }\n */\nexport function isLocale(locale: any): locale is Locale {\n\treturn locales.includes(locale);\n}\n\n// ------ TYPES ------\n\n/**\n * A locale that is available in the project.\n *\n * @example\n *   setLocale(request.locale as Locale)\n *\n */\nexport type Locale = (typeof locales)[number];\n";
+//# sourceMappingURL=ts-runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ts-runtime.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/ts-runtime.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,yrFAqHrB,CAAC"}

package/dist/compiler/runtime/ts-runtime.js

@@ -0,0 +1,119 @@
+// to modify the runtime, outcomment the export const jsdocRuntime line
+export const tsRuntime = `
+// @eslint-disable
+
+/**
+ * The project's base locale.
+ *
+ * @example
+ *   if (locale === baseLocale) {
+ *     // do something
+ *   }
+ */
+export const baseLocale = "<replace>";
+
+/**
+ * The project's locales that have been specified in the settings.
+ *
+ * @example
+ *   if (locales.includes(userSelectedLocale) === false) {
+ *     throw new Error('Locale is not available');
+ *   }
+ */
+export const locales = ["<replace>"] as const;
+
+/**
+ * This is a default implementation that is almost always
+ * overwritten by \`defineGetLocale()\` and \`defineSetLocale()\`.
+ *
+ */
+let _locale: Locale = baseLocale;
+
+/**
+ * Define the \`getLocale()\` function.
+ *
+ * Use this function to define how the locale is resolved. For example,
+ * you can resolve the locale from the browser's preferred language,
+ * a cookie, env variable, or a user's preference.
+ *
+ * @example
+ *   defineGetLocale(() => {
+ *     // resolve the locale from a cookie. fallback to the base locale.
+ *     return Cookies.get('locale') ?? baseLocale
+ *   }
+ *
+ */
+export const defineGetLocale: (fn: () => Locale) => void = (fn) => {
+	getLocale = fn;
+};
+
+/**
+ * Define the \`setLocale()\` function.
+ *
+ * Use this function to define how the locale is set. For example,
+ * modify a cookie, env variable, or a user's preference.
+ *
+ * @example
+ *   defineSetLocale((newLocale) => {
+ *     // set the locale in a cookie
+ *     return Cookies.set('locale', newLocale)
+ *   });
+ *
+ */
+export const defineSetLocale: (fn: (newLocale: Locale) => void) => void = (
+	fn
+) => {
+	setLocale = fn;
+};
+
+/**
+ * Get the current locale.
+ *
+ * @example
+ *   if (getLocale() === 'de') {
+ *     console.log('Germany 🇩🇪');
+ *   } else if (getLocale() === 'nl') {
+ *     console.log('Netherlands 🇳🇱');
+ *   }
+ *
+ */
+export let getLocale: () => Locale =
+	/** default implementation likely overwritten by \`defineGetLocale()\` */ () =>
+		_locale;
+
+/**
+ * Set the locale.
+ *
+ * @example
+ *   setLocale('en');
+ */
+export let setLocale: (newLocale: Locale) => void = (newLocale) => {
+	/** default implementation likely overwritten by \`defineSetLocale()\` */
+	_locale = newLocale;
+};
+
+/**
+ * Check if something is an available locale.
+ *
+ * @example
+ *   if (isLocale(params.locale)) {
+ *     setLocale(params.locale);
+ *   } else {
+ *     setLocale('en');
+ *   }
+ */
+export function isLocale(locale: any): locale is Locale {
+	return locales.includes(locale);
+}
+
+// ------ TYPES ------
+
+/**
+ * A locale that is available in the project.
+ *
+ * @example
+ *   setLocale(request.locale as Locale)
+ *
+ */
+export type Locale = (typeof locales)[number];
+`;

package/dist/compiler/runtime/type.d.ts

@@ -4,8 +4,8 @@
 export type Runtime = {
     baseLocale: Locale;
     locales: Readonly<Locale[]>;
-    strategy: typeof import("./strategy.js").strategy;
-    cookieName: typeof import("./cookie-name.js").cookieName;
+    strategy: typeof import("./variables.js").strategy;
+    cookieName: typeof import("./variables.js").cookieName;
     getLocale: typeof import("./get-locale.js").getLocale;
     setLocale: typeof import("./set-locale.js").setLocale;
     defineGetLocale: (fn: () => Locale) => void;

package/dist/compiler/runtime/type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/type.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IAC5B,QAAQ,EAAE,cAAc,eAAe,EAAE,QAAQ,CAAC;IAClD,UAAU,EAAE,cAAc,kBAAkB,EAAE,UAAU,CAAC;IACzD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,eAAe,EAAE,CAAC,EAAE,EAAE,MAAM,MAAM,KAAK,IAAI,CAAC;IAC5C,eAAe,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,KAAK,IAAI,CAAC;IAC3D,cAAc,EAAE,cAAc,uBAAuB,EAAE,cAAc,CAAC;IACtE,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,cAAc,EAAE,cAAc,uBAAuB,EAAE,cAAc,CAAC;IACtE,YAAY,EAAE,cAAc,oBAAoB,EAAE,YAAY,CAAC;IAC/D,yBAAyB,EAAE,cAAc,mCAAmC,EAAE,yBAAyB,CAAC;IACxG,wBAAwB,EAAE,cAAc,kCAAkC,EAAE,wBAAwB,CAAC;IACrG,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;CAClG,CAAC;AAEF;;GAEG;AACH,KAAK,MAAM,GAAG,GAAG,CAAC"}
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/type.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IAC5B,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,UAAU,EAAE,cAAc,gBAAgB,EAAE,UAAU,CAAC;IACvD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,SAAS,EAAE,cAAc,iBAAiB,EAAE,SAAS,CAAC;IACtD,eAAe,EAAE,CAAC,EAAE,EAAE,MAAM,MAAM,KAAK,IAAI,CAAC;IAC5C,eAAe,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,KAAK,IAAI,CAAC;IAC3D,cAAc,EAAE,cAAc,uBAAuB,EAAE,cAAc,CAAC;IACtE,QAAQ,EAAE,cAAc,gBAAgB,EAAE,QAAQ,CAAC;IACnD,cAAc,EAAE,cAAc,uBAAuB,EAAE,cAAc,CAAC;IACtE,YAAY,EAAE,cAAc,oBAAoB,EAAE,YAAY,CAAC;IAC/D,yBAAyB,EAAE,cAAc,mCAAmC,EAAE,yBAAyB,CAAC;IACxG,wBAAwB,EAAE,cAAc,kCAAkC,EAAE,wBAAwB,CAAC;IACrG,uBAAuB,EAAE,cAAc,iCAAiC,EAAE,uBAAuB,CAAC;CAClG,CAAC;AAEF;;GAEG;AACH,KAAK,MAAM,GAAG,GAAG,CAAC"}

package/dist/compiler/runtime/type.test.js

@@ -1,5 +1,5 @@
 import { expect, test } from "vitest";
-import { createProject as typescriptProject, ts } from "@ts-morph/bootstrap";
+import { createProject as typescriptProject, ts, } from "@ts-morph/bootstrap";
 import { createRuntimeFile } from "./create-runtime.js";
 import fs from "node:fs";
 import { dirname, resolve } from "node:path";
@@ -7,23 +7,31 @@ import { fileURLToPath } from "url";
 import { defaultCompilerOptions } from "../compile.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const superStrictRuleOutAnyErrorTsSettings = {
+    outDir: "dist",
+    declaration: true,
+    allowJs: true,
+    checkJs: true,
+    noImplicitAny: true,
+    noUnusedLocals: true,
+    noUnusedParameters: true,
+    noImplicitReturns: true,
+    noImplicitThis: true,
+    noUncheckedIndexedAccess: true,
+    noPropertyAccessFromIndexSignature: true,
+    module: ts.ModuleKind.Node16,
+    strict: true,
+};
 test("runtime type", async () => {
     const project = await typescriptProject({
         useInMemoryFileSystem: true,
-        compilerOptions: {
-            outDir: "./dist",
-            declaration: true,
-            allowJs: true,
-            checkJs: true,
-            module: ts.ModuleKind.Node16,
-            strict: true,
-        },
+        compilerOptions: superStrictRuleOutAnyErrorTsSettings,
     });
     const jsdocRuntime = createRuntimeFile({
         baseLocale: "en",
         locales: ["en"],
         compilerOptions: defaultCompilerOptions,
-    });
+    }).replace('import * as pathToRegexp from "@inlang/paraglide-js/path-to-regexp";', "");
     const file = (path) => {
         return [path, fs.readFileSync(resolve(__dirname, path), "utf-8")];
     };
@@ -41,12 +49,41 @@ test("runtime type", async () => {
     import type { Runtime } from "./type.js"
 
     runtime satisfies Runtime
+
+		// getLocale() should return type should be a union of language tags, not a generic string
+    runtime.getLocale() satisfies "de" | "en" | "en-US"
+
+    // locales should have a narrow type, not a generic string
+    runtime.locales satisfies Readonly<Array<"de" | "en" | "en-US">>
+
+    // setLocale() should fail if the given language tag is not included in locales
+    // @ts-expect-error - invalid locale
+    runtime.setLocale("fr")
+
+    // setLocale() should not fail if the given language tag is included in locales
+    runtime.setLocale("de")
+
+		// isLocale should narrow the type of it's argument
+		const thing = 5;
+
+		let a: "de" | "en" | "en-US";
+
+		if(runtime.isLocale(thing)) {
+			a = thing
+		} else {
+			// @ts-expect-error - thing is not a language tag
+			a = thing
+		}
+
+		// to make ts not complain about unused variables
+		console.log(a)
     `);
     const program = project.createProgram();
     const diagnostics = ts
         .getPreEmitDiagnostics(program)
         // ignore 'export' modifier cannot be applied to ambient modules and module augmentations since they are always visible. /ambient.d.ts
-        .filter((d) => d.code !== 2668);
+        .filter((d) => d.code !== 2668)
+        .filter((d) => d.messageText.toString().includes("path-to-regexp"));
     for (const diagnostic of diagnostics) {
         console.error(diagnostic.messageText, diagnostic.file?.fileName);
     }

package/dist/compiler/runtime/variables.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The project's base locale.
+ *
+ * @example
+ *   if (locale === baseLocale) {
+ *     // do something
+ *   }
+ */
+export const baseLocale: "en";
+/**
+ * The project's locales that have been specified in the settings.
+ *
+ * @example
+ *   if (locales.includes(userSelectedLocale) === false) {
+ *     throw new Error('Locale is not available');
+ *   }
+ */
+export const locales: readonly ["en", "de"];
+/** @type {string} */
+export const cookieName: string;
+/**
+ * @type {Array<"cookie" | "baseLocale" | "pathname" | "globalVariable">}
+ */
+export const strategy: Array<"cookie" | "baseLocale" | "pathname" | "globalVariable">;
+/**
+ * The localized pathnames.
+ *
+ * @type {Record<string, Record<Locale, string>>}
+ */
+export const pathnames: Record<string, Record<Locale, string>>;
+/** @type {string | undefined} */
+export const pathnameBase: string | undefined;
+/**
+ * Whether the pathnames are the default pathnames.
+ *
+ * If the default pathnames are used, the matching is done
+ * statically with no runtime matching logic which reduces
+ * the bundlesize.
+ *
+ * @type {boolean}
+ */
+export const TREE_SHAKE_IS_DEFAULT_PATHNAMES: boolean;
+export const TREE_SHAKE_COOKIE_STRATEGY_USED: false;
+export const TREE_SHAKE_PATHNAME_STRATEGY_USED: false;
+export const TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED: false;
+//# sourceMappingURL=variables.d.ts.map

package/dist/compiler/runtime/variables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variables.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/variables.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,yBAA0B,IAAI,CAAC;AAE/B;;;;;;;GAOG;AACH,4CAA2D;AAE3D,qBAAqB;AACrB,yBADW,MAAM,CACyB;AAE1C;;GAEG;AACH,uBAFU,KAAK,CAAC,QAAQ,GAAG,YAAY,GAAG,UAAU,GAAG,gBAAgB,CAAC,CAE7B;AAE3C;;;;GAIG;AACH,wBAFU,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAEpB;AAE5B,iCAAiC;AACjC,2BADW,MAAM,GAAG,SAAS,CACS;AAEtC;;;;;;;;GAQG;AACH,8CAFU,OAAO,CAEoC;AAErD,8CAA+C,KAAK,CAAC;AAErD,gDAAiD,KAAK,CAAC;AAEvD,uDAAwD,KAAK,CAAC"}

package/dist/compiler/runtime/variables.js

@@ -0,0 +1,45 @@
+/**
+ * The project's base locale.
+ *
+ * @example
+ *   if (locale === baseLocale) {
+ *     // do something
+ *   }
+ */
+export const baseLocale = "en";
+/**
+ * The project's locales that have been specified in the settings.
+ *
+ * @example
+ *   if (locales.includes(userSelectedLocale) === false) {
+ *     throw new Error('Locale is not available');
+ *   }
+ */
+export const locales = /** @type {const} */ (["en", "de"]);
+/** @type {string} */
+export const cookieName = "<cookie-name>";
+/**
+ * @type {Array<"cookie" | "baseLocale" | "pathname" | "globalVariable">}
+ */
+export const strategy = ["globalVariable"];
+/**
+ * The localized pathnames.
+ *
+ * @type {Record<string, Record<Locale, string>>}
+ */
+export const pathnames = {};
+/** @type {string | undefined} */
+export const pathnameBase = undefined;
+/**
+ * Whether the pathnames are the default pathnames.
+ *
+ * If the default pathnames are used, the matching is done
+ * statically with no runtime matching logic which reduces
+ * the bundlesize.
+ *
+ * @type {boolean}
+ */
+export const TREE_SHAKE_IS_DEFAULT_PATHNAMES = false;
+export const TREE_SHAKE_COOKIE_STRATEGY_USED = false;
+export const TREE_SHAKE_PATHNAME_STRATEGY_USED = false;
+export const TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED = false;

package/dist/compiler/strategy.d.ts

@@ -0,0 +1,13 @@
+export type CookieStrategy = {
+    type: "cookie";
+    cookieName: string;
+};
+export type I18nRoutingStrategy = {
+    type: "i18n-routing";
+};
+export type CustomStrategy = {
+    type: "custom";
+};
+export type Strategy = CookieStrategy | CustomStrategy | I18nRoutingStrategy;
+export declare function createStrategyFile(strategy: Strategy): string;
+//# sourceMappingURL=strategy.d.ts.map

package/dist/compiler/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../src/compiler/strategy.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,cAAc,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,QAAQ,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,cAAc,GAAG,cAAc,GAAG,mBAAmB,CAAC;AAI7E,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAe7D"}

package/dist/compiler/strategy.js

@@ -0,0 +1,12 @@
+const variableNames = ["cookieName"];
+export function createStrategyFile(strategy) {
+    let result = `/** @type {"cookie" | "custom" | "i18n-routing"} */
+export const type = ${JSON.stringify(strategy.type, null, `\t`)}
+`;
+    for (const name of variableNames) {
+        result += `export const ${name} = ${JSON.stringify(
+        // @ts-expect-error - typescript is not smart enough to know that the name is a valid key of the strategy object
+        strategy[name], null, `\t`)}\n`;
+    }
+    return result;
+}

package/dist/compiler/strategy.test.d.ts

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

package/dist/compiler/strategy.test.d.ts.map

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

package/dist/compiler/strategy.test.js

@@ -0,0 +1,9 @@
+import { test, expect } from "vitest";
+import { createStrategyFile } from "./strategy.js";
+test("creates the exports for a strategy", () => {
+    const result = createStrategyFile({ type: "cookie", cookieName: "locale" });
+    expect(result).toBe(`/** @type {"cookie" | "custom" | "i18n-routing"} */
+export const type = "cookie"
+export const cookieName = "locale"
+`);
+});

package/dist/path-to-regexp/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This is a re-export of the path-to-regexp library.
+ *
+ * The bundling is required to (1) avoid dependency resolution issues
+ * because paraglide emits into source code and (2) enable tree-shaking
+ * by tricking the bundler to treat path-to-regexp as ESM instead of
+ * CJS dependency.
+ *
+ * See https://github.com/pillarjs/path-to-regexp for more information.
+ */
+export { match, compile } from "path-to-regexp";
+//# sourceMappingURL=index.d.ts.map

package/dist/path-to-regexp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/path-to-regexp/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/path-to-regexp/index.js

@@ -0,0 +1,11 @@
+/**
+ * This is a re-export of the path-to-regexp library.
+ *
+ * The bundling is required to (1) avoid dependency resolution issues
+ * because paraglide emits into source code and (2) enable tree-shaking
+ * by tricking the bundler to treat path-to-regexp as ESM instead of
+ * CJS dependency.
+ *
+ * See https://github.com/pillarjs/path-to-regexp for more information.
+ */
+export { match, compile } from "path-to-regexp";

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

@@ -1,5 +1,5 @@
 export const ENV_VARIABLES = {
     PARJS_APP_ID: "library.inlang.paraglideJs",
     PARJS_POSTHOG_TOKEN: "phc_m5yJZCxjOGxF8CJvP5sQ3H0d76xpnLrsmiZHduT4jDz",
-    PARJS_PACKAGE_VERSION: "2.0.0-beta.15",
+    PARJS_PACKAGE_VERSION: "2.0.0-beta.16",
 };

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

@@ -1,3 +1,8 @@
 import type nodeFs from "node:fs/promises";
-export declare function writeOutput(outputDirectory: string, output: Record<string, string>, fs: typeof nodeFs): Promise<void>;
+export declare function writeOutput(args: {
+    directory: string;
+    output: Record<string, string>;
+    fs: typeof nodeFs;
+    previousOutputHashes?: Record<string, string>;
+}): Promise<Record<string, string> | undefined>;
 //# sourceMappingURL=write-output.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"write-output.d.ts","sourceRoot":"","sources":["../../../src/services/file-handling/write-output.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAI3C,wBAAsB,WAAW,CAChC,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,EAAE,EAAE,OAAO,MAAM,iBA6BjB"}
+{"version":3,"file":"write-output.d.ts","sourceRoot":"","sources":["../../../src/services/file-handling/write-output.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,kBAAkB,CAAC;AAE3C,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,EAAE,EAAE,OAAO,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9C,+CA4CA"}