cloudflare-next-intl 0.10.6 → 0.10.7

package/dist/src/firebase_auth_check/check_firebase_auth_config.d.ts

@@ -27,3 +27,8 @@ export declare function extractFieldValue(body: string, key: string): {
 } | null;
 export declare function formatFirebaseAuthConfigMessage(issues: FirebaseAuthConfigIssue[], intlConfigPath?: string): string;
 export declare function checkFirebaseAuthConfig(options?: CheckFirebaseAuthConfigOptions): CheckFirebaseAuthConfigReport;
+export interface ValidateFirebaseAuthConfigValuesOptions {
+    firebaseAuth: Record<string, unknown> | undefined;
+    intlConfigPath?: string;
+}
+export declare function validateFirebaseAuthConfigValues(options: ValidateFirebaseAuthConfigValuesOptions): CheckFirebaseAuthConfigReport;

package/dist/src/firebase_auth_check/check_firebase_auth_config.js

@@ -337,7 +337,29 @@ function resolveSpreadBodies(mainBody, source, fromFile, cache) {
     return { bodies, hasUnresolvedSpread };
 }
 export function extractFieldValue(body, key) {
-    const keyMatch = new RegExp(`(^|[\\s{,])${key}\\s*:`).exec(maskCommentsAndStrings(body));
+    const masked = maskCommentsAndStrings(body);
+    const keyPattern = new RegExp(`^${key}\\s*:`);
+    let searchDepth = 0;
+    let scanIndex = 0;
+    let keyMatch = null;
+    while (scanIndex < masked.length) {
+        const char = masked[scanIndex];
+        if (char === "{" || char === "[" || char === "(") {
+            searchDepth += 1;
+        }
+        else if (char === "}" || char === "]" || char === ")") {
+            searchDepth -= 1;
+        }
+        else if (searchDepth === 0 && (scanIndex === 0 || /[\s{,]/.test(masked[scanIndex - 1]))) {
+            const candidate = keyPattern.exec(masked.slice(scanIndex));
+            if (candidate) {
+                keyMatch = candidate;
+                keyMatch.index = scanIndex;
+                break;
+            }
+        }
+        scanIndex += 1;
+    }
     if (!keyMatch)
         return null;
     const start = keyMatch.index + keyMatch[0].length;
@@ -531,3 +553,54 @@ export function checkFirebaseAuthConfig(options = {}) {
     }
     return { valid, checked: true, issues, formattedMessage };
 }
+function isUsableFieldValue(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (typeof value === "string")
+        return value.trim() !== "";
+    return true;
+}
+const UNUSABLE_REASON = "resolved to an empty or missing value";
+export function validateFirebaseAuthConfigValues(options) {
+    const { firebaseAuth } = options;
+    if (!firebaseAuth) {
+        return { valid: true, checked: false, issues: [], formattedMessage: "" };
+    }
+    const issues = [];
+    for (const key of REQUIRED_AUTH_FIELDS) {
+        if (!isUsableFieldValue(firebaseAuth[key])) {
+            issues.push({ field: `firebaseAuth.${key}`, severity: "error", reason: UNUSABLE_REASON });
+        }
+    }
+    const appCheck = firebaseAuth.appCheck;
+    if (appCheck && appCheck.reportMissingServerCredentials !== false) {
+        for (const key of REQUIRED_APP_CHECK_FIELDS) {
+            if (!isUsableFieldValue(appCheck[key])) {
+                issues.push({ field: `firebaseAuth.appCheck.${key}`, severity: "warning", reason: UNUSABLE_REASON });
+            }
+        }
+        const hasPrivateKey = isUsableFieldValue(appCheck.privateKey);
+        const tripleUsable = OAUTH_TRIPLE.map((key) => isUsableFieldValue(appCheck[key]));
+        const hasTriple = tripleUsable.every(Boolean);
+        if (!hasPrivateKey && !hasTriple) {
+            const hasPartialTriple = tripleUsable.some(Boolean);
+            if (hasPartialTriple) {
+                OAUTH_TRIPLE.forEach((key, index) => {
+                    if (!tripleUsable[index]) {
+                        issues.push({ field: `firebaseAuth.appCheck.${key}`, severity: "warning", reason: UNUSABLE_REASON });
+                    }
+                });
+            }
+            else {
+                issues.push({
+                    field: "firebaseAuth.appCheck.privateKey",
+                    severity: "warning",
+                    reason: UNUSABLE_REASON + " — set it, or the full oauthClientId/oauthClientSecret/oauthRefreshToken triple",
+                });
+            }
+        }
+    }
+    const valid = !issues.some((issue) => issue.severity === "error");
+    const formattedMessage = formatFirebaseAuthConfigMessage(issues, options.intlConfigPath);
+    return { valid, checked: true, issues, formattedMessage };
+}

package/dist/src/firebase_auth_check/index.d.ts

@@ -1 +1,2 @@
-export { checkFirebaseAuthConfig, formatFirebaseAuthConfigMessage, extractObjectLiteral, extractFieldValue, type FirebaseAuthConfigIssue, type CheckFirebaseAuthConfigOptions, type CheckFirebaseAuthConfigReport, } from "./check_firebase_auth_config.js";
+export { checkFirebaseAuthConfig, validateFirebaseAuthConfigValues, formatFirebaseAuthConfigMessage, extractObjectLiteral, extractFieldValue, type FirebaseAuthConfigIssue, type CheckFirebaseAuthConfigOptions, type CheckFirebaseAuthConfigReport, type ValidateFirebaseAuthConfigValuesOptions, } from "./check_firebase_auth_config.js";
+export { loadResolvedFirebaseAuth, type LoadResolvedFirebaseAuthOptions } from "./load_resolved_firebase_auth.js";

package/dist/src/firebase_auth_check/index.js

@@ -1 +1,2 @@
-export { checkFirebaseAuthConfig, formatFirebaseAuthConfigMessage, extractObjectLiteral, extractFieldValue, } from "./check_firebase_auth_config.js";
+export { checkFirebaseAuthConfig, validateFirebaseAuthConfigValues, formatFirebaseAuthConfigMessage, extractObjectLiteral, extractFieldValue, } from "./check_firebase_auth_config.js";
+export { loadResolvedFirebaseAuth } from "./load_resolved_firebase_auth.js";

package/dist/src/firebase_auth_check/load_resolved_firebase_auth.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedConfig } from "vite";
+export interface LoadResolvedFirebaseAuthOptions {
+    intlConfigPath: string;
+    viteConfig: Pick<ResolvedConfig, "root" | "envDir" | "mode"> & {
+        resolve: Pick<ResolvedConfig["resolve"], "alias">;
+    };
+}
+export declare function loadResolvedFirebaseAuth(options: LoadResolvedFirebaseAuthOptions): Promise<Record<string, unknown> | undefined>;

package/dist/src/firebase_auth_check/load_resolved_firebase_auth.js

@@ -0,0 +1,51 @@
+export async function loadResolvedFirebaseAuth(options) {
+    let server;
+    try {
+        const { createServer } = await import("vite");
+        server = await createServer({
+            configFile: false,
+            root: options.viteConfig.root,
+            envDir: options.viteConfig.envDir,
+            mode: options.viteConfig.mode,
+            resolve: { alias: options.viteConfig.resolve.alias },
+            server: { middlewareMode: true, hmr: false, watch: null },
+            optimizeDeps: { noDiscovery: true },
+            logLevel: "silent",
+            clearScreen: false,
+            ssr: { noExternal: ["cloudflare-next-intl", /^cloudflare:/] },
+            plugins: [
+                {
+                    name: "cfni:firebase-auth-check-intl-config-alias",
+                    enforce: "pre",
+                    resolveId(id) {
+                        if (id === "@intl-config")
+                            return options.intlConfigPath;
+                        if (id === "cloudflare:workers" || id.startsWith("cloudflare:")) {
+                            return "\0cfni:cloudflare-workers-stub";
+                        }
+                    },
+                    load(id) {
+                        if (id === "\0cfni:cloudflare-workers-stub") {
+                            return ("export class WorkerEntrypoint {}\n" +
+                                "export class DurableObject {}\n" +
+                                "export const env = {};\n" +
+                                "export default {};\n");
+                        }
+                    },
+                },
+            ],
+        });
+        const mod = await server.ssrLoadModule(options.intlConfigPath);
+        const exported = mod.default;
+        const firebaseAuth = exported?.firebaseAuth;
+        return firebaseAuth && typeof firebaseAuth === "object"
+            ? firebaseAuth
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await server?.close();
+    }
+}

package/dist/src/vite/firebase_auth_check_plugin.js

@@ -1,4 +1,4 @@
-import { checkFirebaseAuthConfig } from "../firebase_auth_check/index.js";
+import { checkFirebaseAuthConfig, validateFirebaseAuthConfigValues, loadResolvedFirebaseAuth, } from "../firebase_auth_check/index.js";
 import { resolveDefaultIntlConfigPath } from "./locale_file_plugin.js";
 export function firebaseAuthCheckPlugin(options = {}) {
     let ran = false;
@@ -23,7 +23,21 @@ export function firebaseAuthCheckPlugin(options = {}) {
                     ...process.env,
                 };
             }
-            const report = checkFirebaseAuthConfig({ intlConfigPath, env, throwOnError: false });
+            const previousEnv = { ...process.env };
+            Object.assign(process.env, env);
+            let firebaseAuth;
+            try {
+                firebaseAuth = await loadResolvedFirebaseAuth({
+                    intlConfigPath,
+                    viteConfig: { root: config.root, envDir: config.envDir, mode: config.mode, resolve: { alias: config.resolve?.alias } },
+                });
+            }
+            finally {
+                process.env = previousEnv;
+            }
+            const report = firebaseAuth !== undefined
+                ? validateFirebaseAuthConfigValues({ firebaseAuth, intlConfigPath })
+                : checkFirebaseAuthConfig({ intlConfigPath, env, throwOnError: false });
             if (report.issues.length === 0)
                 return;
             console.warn(report.formattedMessage);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-next-intl",
-  "version": "0.10.6",
+  "version": "0.10.7",
   "description": "Optimized Next Intl Package Special for App Router and Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",