@inlang/paraglide-js 2.4.0 → 2.6.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/bundler-plugins/webpack.d.ts

@@ -1,2 +1,2 @@
-export declare const paraglideWebpackPlugin: (options: import("../index.js").CompilerOptions) => import("unplugin").WebpackPluginInstance;
+export declare const paraglideWebpackPlugin: (options: import("../index.js").CompilerOptions) => WebpackPluginInstance;
 //# sourceMappingURL=webpack.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"webpack.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/webpack.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,sBAAsB,8FAAuC,CAAC"}
+{"version":3,"file":"webpack.d.ts","sourceRoot":"","sources":["../../src/bundler-plugins/webpack.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,sBAAsB,2EAAuC,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/compile-bundle.js

@@ -49,7 +49,7 @@ ${isSafeBundleId ? "export " : ""}const ${safeBundleId} = (inputs${hasInputs ? "
 	trackMessageCall("${safeBundleId}", locale)
 	${args.availableLocales
         .map((locale, index) => `${index > 0 ? "	" : ""}${!isFullyTranslated || index < args.availableLocales.length - 1 ? `if (locale === "${locale}") ` : ""}return ${args.messageReferenceExpression(locale, args.bundle.id)}(inputs)`)
-        .join("\n")}${!isFullyTranslated ? `\n	return "${args.bundle.id}"` : ""}
+        .join("\n")}${!isFullyTranslated ? `\n	return /** @type {LocalizedString} */ ("${args.bundle.id}")` : ""}
 };`;
     if (isSafeBundleId === false) {
         code += `\nexport { ${safeBundleId} as "${escapeForDoubleQuoteString(args.bundle.id)}" }`;

package/dist/compiler/compile-bundle.test.js

@@ -49,7 +49,7 @@ test("compiles to jsdoc", async () => {
 * 
 * @param {{ age: NonNullable<unknown> }} inputs
 * @param {{ locale?: "en" | "en-US" }} options
-* @returns {string}
+* @returns {LocalizedString}
 */
 /* @__NO_SIDE_EFFECTS__ */
 export const blue_moon_bottle = (inputs, options = {}) => {
@@ -100,29 +100,31 @@ test("compiles to jsdoc with missing translation", async () => {
             locales: ["en", "en-US", "fr"],
         },
     });
-    expect(result.bundle.code).toMatchInlineSnapshot(`"/**
-* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
-*
-* - Changing this function will be over-written by the next build.
-*
-* - If you want to change the translations, you can either edit the source files e.g. \`en.json\`, or
-* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
-* 
-* @param {{ age: NonNullable<unknown> }} inputs
-* @param {{ locale?: "en" | "en-US" }} options
-* @returns {string}
-*/
-/* @__NO_SIDE_EFFECTS__ */
-export const blue_moon_bottle = (inputs, options = {}) => {
-	if (experimentalMiddlewareLocaleSplitting && isServer === false) {
-		return /** @type {any} */ (globalThis).__paraglide_ssr.blue_moon_bottle(inputs) 
-	}
-	const locale = options.locale ?? getLocale()
-	trackMessageCall("blue_moon_bottle", locale)
-	if (locale === "en") return en.blue_moon_bottle(inputs)
-	if (locale === "en-US") return en_us2.blue_moon_bottle(inputs)
-	return "blue_moon_bottle"
-};"`);
+    expect(result.bundle.code).toMatchInlineSnapshot(`
+		"/**
+		* This function has been compiled by [Paraglide JS](https://inlang.com/m/gerre34r).
+		*
+		* - Changing this function will be over-written by the next build.
+		*
+		* - If you want to change the translations, you can either edit the source files e.g. \`en.json\`, or
+		* use another inlang app like [Fink](https://inlang.com/m/tdozzpar) or the [VSCode extension Sherlock](https://inlang.com/m/r7kp499g).
+		* 
+		* @param {{ age: NonNullable<unknown> }} inputs
+		* @param {{ locale?: "en" | "en-US" }} options
+		* @returns {LocalizedString}
+		*/
+		/* @__NO_SIDE_EFFECTS__ */
+		export const blue_moon_bottle = (inputs, options = {}) => {
+			if (experimentalMiddlewareLocaleSplitting && isServer === false) {
+				return /** @type {any} */ (globalThis).__paraglide_ssr.blue_moon_bottle(inputs) 
+			}
+			const locale = options.locale ?? getLocale()
+			trackMessageCall("blue_moon_bottle", locale)
+			if (locale === "en") return en.blue_moon_bottle(inputs)
+			if (locale === "en-US") return en_us2.blue_moon_bottle(inputs)
+			return /** @type {LocalizedString} */ ("blue_moon_bottle")
+		};"
+	`);
 });
 // https://github.com/opral/inlang-paraglide-js/issues/285
 test("compiles bundles with arbitrary module identifiers", async () => {
@@ -208,5 +210,5 @@ test("handles message pattern with duplicate variable references", async () => {
     // Check that the pattern is compiled correctly
     const enMessage = result.messages?.en;
     expect(enMessage).toBeDefined();
-    expect(enMessage?.code).toContain("Last ${i.days} days, showing ${i.days} items");
+    expect(enMessage?.code).toContain("Last ${i?.days} days, showing ${i?.days} items");
 });

package/dist/compiler/compile-local-variable.js

@@ -33,6 +33,6 @@ function compileLiteralOrVarRef(value) {
         case "literal":
             return `"${value.value}"`;
         case "variable-reference":
-            return `i.${value.name}`;
+            return `i?.${value.name}`;
     }
 }

package/dist/compiler/compile-local-variable.test.js

@@ -23,7 +23,7 @@ test("compiles a variable reference local variable", () => {
             },
         },
     });
-    expect(code).toEqual("const myVar = i.name;");
+    expect(code).toEqual("const myVar = i?.name;");
 });
 test("compiles a local variable with an annotation and empty options", () => {
     const code = compileLocalVariable({
@@ -67,5 +67,5 @@ test("compiles a local variable with an annotation and options", () => {
             },
         },
     });
-    expect(code).toEqual('const myVar = registry.myFunction("en", "Hello", { option1: "value1", option2: i.varRef });');
+    expect(code).toEqual('const myVar = registry.myFunction("en", "Hello", { option1: "value1", option2: i?.varRef });');
 });

package/dist/compiler/compile-message.js

@@ -33,8 +33,8 @@ function compileMessageWithOneVariant(declarations, message, variants) {
             compiledLocalVariables.push(compileLocalVariable({ declaration, locale: message.locale }));
         }
     }
-    const code = `/** @type {(inputs: ${inputsType(inputs)}) => string} */ (${hasInputs ? "i" : ""}) => {
-	${compiledLocalVariables.join("\n\t")}return ${compiledPattern.code}
+    const code = `/** @type {(inputs: ${inputsType(inputs)}) => LocalizedString} */ (${hasInputs ? "i" : ""}) => {
+	${compiledLocalVariables.join("\n\t")}return /** @type {LocalizedString} */ (${compiledPattern.code})
 };`;
     return { code, node: message };
 }
@@ -54,7 +54,7 @@ function compileMessageWithMultipleVariants(declarations, message, variants) {
         });
         const isCatchAll = variant.matches.every((match) => match.type === "catchall-match");
         if (isCatchAll) {
-            compiledVariants.push(`return ${compiledPattern.code}`);
+            compiledVariants.push(`return /** @type {LocalizedString} */ (${compiledPattern.code})`);
             hasCatchAll = true;
         }
         const conditions = [];
@@ -65,7 +65,7 @@ function compileMessageWithMultipleVariants(declarations, message, variants) {
             }
             const variableType = declarations.find((decl) => decl.name === match.key)?.type;
             if (variableType === "input-variable") {
-                conditions.push(`i.${match.key} == ${doubleQuote(match.value)}`);
+                conditions.push(`i?.${match.key} == ${doubleQuote(match.value)}`);
             }
             else if (variableType === "local-variable") {
                 conditions.push(`${match.key} == ${doubleQuote(match.value)}`);
@@ -73,7 +73,7 @@ function compileMessageWithMultipleVariants(declarations, message, variants) {
         }
         if (conditions.length === 0)
             continue;
-        compiledVariants.push(`if (${conditions.join(" && ")}) return ${compiledPattern.code};`);
+        compiledVariants.push(`if (${conditions.join(" && ")}) return /** @type {LocalizedString} */ (${compiledPattern.code});`);
     }
     const compiledLocalVariables = [];
     for (const declaration of declarations) {
@@ -81,9 +81,9 @@ function compileMessageWithMultipleVariants(declarations, message, variants) {
             compiledLocalVariables.push(compileLocalVariable({ declaration, locale: message.locale }));
         }
     }
-    const code = `/** @type {(inputs: ${inputsType(inputs)}) => string} */ (${hasInputs ? "i" : ""}) => {${compiledLocalVariables.join("\n\t")}
+    const code = `/** @type {(inputs: ${inputsType(inputs)}) => LocalizedString} */ (${hasInputs ? "i" : ""}) => {${compiledLocalVariables.join("\n\t")}
 	${compiledVariants.join("\n\t")}
-	${hasCatchAll ? "" : `return "${message.bundleId}";`}
+	${hasCatchAll ? "" : `return /** @type {LocalizedString} */ ("${message.bundleId}");`}
 };`;
     return { code, node: message };
 }

package/dist/compiler/compile-message.test.js

@@ -142,7 +142,7 @@ test("only emits input arguments when inputs exist", async () => {
         },
     ];
     const compiled = compileMessage(declarations, message, variants);
-    expect(compiled.code).toBe("/** @type {(inputs: {}) => string} */ () => {\n\treturn `Hello`\n};");
+    expect(compiled.code).toBe("/** @type {(inputs: {}) => LocalizedString} */ () => {\n\treturn /** @type {LocalizedString} */ (`Hello`)\n};");
 });
 // https://github.com/opral/inlang-paraglide-js/issues/379
 test("compiles messages that use plural()", async () => {
@@ -198,6 +198,90 @@ test("compiles messages that use plural()", async () => {
     // INTL.plural will match "other" for undefined
     expect(plural_test({ count: undefined })).toBe("There are many cats.");
 });
+test("compiles messages that use plural() with ordinal type", async () => {
+    const declarations = [
+        { type: "input-variable", name: "count" },
+        {
+            type: "local-variable",
+            name: "countOrdinal",
+            value: {
+                arg: { type: "variable-reference", name: "count" },
+                annotation: {
+                    type: "function-reference",
+                    name: "plural",
+                    options: [
+                        { name: "type", value: { type: "literal", value: "ordinal" } },
+                    ],
+                },
+                type: "expression",
+            },
+        },
+    ];
+    const message = {
+        locale: "en",
+        bundleId: "ordinal_test",
+        id: "message_id",
+        selectors: [{ type: "variable-reference", name: "countOrdinal" }],
+    };
+    const variants = [
+        {
+            id: "1",
+            messageId: "message_id",
+            matches: [{ type: "literal-match", value: "one", key: "countOrdinal" }],
+            pattern: [
+                {
+                    type: "expression",
+                    arg: { type: "variable-reference", name: "count" },
+                },
+                { type: "text", value: "st place" },
+            ],
+        },
+        {
+            id: "2",
+            messageId: "message_id",
+            matches: [{ type: "literal-match", value: "two", key: "countOrdinal" }],
+            pattern: [
+                {
+                    type: "expression",
+                    arg: { type: "variable-reference", name: "count" },
+                },
+                { type: "text", value: "nd place" },
+            ],
+        },
+        {
+            id: "3",
+            messageId: "message_id",
+            matches: [{ type: "literal-match", value: "few", key: "countOrdinal" }],
+            pattern: [
+                {
+                    type: "expression",
+                    arg: { type: "variable-reference", name: "count" },
+                },
+                { type: "text", value: "rd place" },
+            ],
+        },
+        {
+            id: "4",
+            messageId: "message_id",
+            matches: [{ type: "literal-match", value: "other", key: "countOrdinal" }],
+            pattern: [
+                {
+                    type: "expression",
+                    arg: { type: "variable-reference", name: "count" },
+                },
+                { type: "text", value: "th place" },
+            ],
+        },
+    ];
+    const compiled = compileMessage(declarations, message, variants);
+    const { ordinal_test } = await import("data:text/javascript;base64," +
+        btoa(createRegistry()) +
+        btoa("export const ordinal_test = " + compiled.code.replace("registry.", "")));
+    expect(ordinal_test({ count: 1 })).toBe("1st place");
+    expect(ordinal_test({ count: 2 })).toBe("2nd place");
+    expect(ordinal_test({ count: 3 })).toBe("3rd place");
+    expect(ordinal_test({ count: 4 })).toBe("4th place");
+});
 test("compiles messages that use datetime()", async () => {
     const createMessage = async (locale) => {
         const declarations = [
@@ -306,3 +390,65 @@ test("compiles messages that use datetime a function with options", async () =>
     expect(enMessage({ date: "2022-03-31" })).toMatch(/Today is March \d{1,2}\./);
     expect(deMessage({ date: "2022-03-31" })).toMatch(/Today is \d{1,2}\. März\./);
 });
+test("does not throw when input is omitted for a single-variant message", async () => {
+    const declarations = [
+        { type: "input-variable", name: "name" },
+    ];
+    const message = {
+        locale: "en",
+        bundleId: "greeting",
+        id: "greeting",
+        selectors: [{ type: "variable-reference", name: "name" }],
+    };
+    const variants = [
+        {
+            id: "1",
+            messageId: "greeting",
+            matches: [{ type: "catchall-match", key: "name" }],
+            pattern: [
+                { type: "text", value: "Hello " },
+                {
+                    type: "expression",
+                    arg: { type: "variable-reference", name: "name" },
+                },
+                { type: "text", value: "!" },
+            ],
+        },
+    ];
+    const compiled = compileMessage(declarations, message, variants);
+    const { greeting } = await import("data:text/javascript;base64," +
+        btoa("export const greeting = " + compiled.code));
+    expect(() => greeting()).not.toThrow();
+    expect(greeting()).toBe("Hello undefined!");
+});
+test("does not throw when input is omitted for multi-variant message", async () => {
+    const declarations = [
+        { type: "input-variable", name: "status" },
+    ];
+    const message = {
+        locale: "en",
+        bundleId: "status_message",
+        id: "status_message",
+        selectors: [{ type: "variable-reference", name: "status" }],
+    };
+    const variants = [
+        {
+            id: "1",
+            messageId: "status_message",
+            matches: [{ type: "literal-match", key: "status", value: "ready" }],
+            pattern: [{ type: "text", value: "Ready to go" }],
+        },
+        {
+            id: "2",
+            messageId: "status_message",
+            matches: [{ type: "catchall-match", key: "status" }],
+            pattern: [{ type: "text", value: "Unknown status" }],
+        },
+    ];
+    const compiled = compileMessage(declarations, message, variants);
+    const { status_message } = await import("data:text/javascript;base64," +
+        btoa("export const status_message = " + compiled.code));
+    expect(status_message({ status: "ready" })).toBe("Ready to go");
+    expect(() => status_message()).not.toThrow();
+    expect(status_message()).toBe("Unknown status");
+});

package/dist/compiler/compile-pattern.d.ts

@@ -11,7 +11,7 @@ import type { Compiled } from "./types.js";
  *
  *   const { code } = compilePattern({ pattern, declarations: [{ type: "input-variable", name: "age" }] });
  *
- *   // code will be: `Your age is ${i.age}`
+ *   // code will be: `Your age is ${i?.age}`
  */
 export declare const compilePattern: (args: {
     pattern: Pattern;

package/dist/compiler/compile-pattern.js

@@ -10,7 +10,7 @@ import { escapeForTemplateLiteral } from "../services/codegen/escape.js";
  *
  *   const { code } = compilePattern({ pattern, declarations: [{ type: "input-variable", name: "age" }] });
  *
- *   // code will be: `Your age is ${i.age}`
+ *   // code will be: `Your age is ${i?.age}`
  */
 export const compilePattern = (args) => {
     let result = "";
@@ -22,7 +22,7 @@ export const compilePattern = (args) => {
             if (part.arg.type === "variable-reference") {
                 const declaration = args.declarations.find((decl) => decl.name === part.arg.name);
                 if (declaration?.type === "input-variable") {
-                    result += `\${i.${part.arg.name}}`;
+                    result += `\${i?.${part.arg.name}}`;
                 }
                 else if (declaration?.type === "local-variable") {
                     result += `\${${part.arg.name}}`;

package/dist/compiler/compile-pattern.test.js

@@ -26,7 +26,7 @@ test("should compile a pattern with multiple VariableReference's", () => {
             { type: "input-variable", name: "count" },
         ],
     });
-    expect(code).toBe("`Hello ${i.name}! You have ${i.count} messages.`");
+    expect(code).toBe("`Hello ${i?.name}! You have ${i?.count} messages.`");
 });
 test("should escape backticks", () => {
     const pattern = [{ type: "text", value: "`Hello world`" }];