@comvi/next 0.1.0

package/dist/routing/hooks.js

@@ -0,0 +1,102 @@
+"use client";
+"use client";
+import { useRoutingConfig } from "./context.js";
+import { getCanonicalPathname, localizeHref, stripLocalePrefix } from "./utils.js";
+import { useCallback } from "react";
+import { useI18n } from "@comvi/react";
+import { usePathname, useRouter } from "next/navigation";
+//#region src/routing/hooks.ts
+/**
+* Get pathname without locale prefix
+*
+* This hook returns the current pathname with the locale prefix removed,
+* making it easier to work with routes in a locale-agnostic way.
+*
+* @returns Pathname without locale prefix
+*
+* @example
+* ```tsx
+* import { usePathname } from '@comvi/next/navigation';
+*
+* function MyComponent() {
+*   const pathname = usePathname();
+*   // If URL is /en/about, pathname is /about
+*   return <p>Current page: {pathname}</p>;
+* }
+* ```
+*/
+function usePathname$1() {
+	const pathname = usePathname() ?? "/";
+	const routing = useRoutingConfig();
+	const { locale } = useI18n();
+	if (routing) return getCanonicalPathname(stripLocalePrefix(pathname, routing.locales), routing, locale);
+	if (pathname.startsWith(`/${locale}/`)) return pathname.slice(locale.length + 1);
+	if (pathname === `/${locale}`) return "/";
+	return pathname;
+}
+/**
+* Localized router with automatic locale prefixing
+*
+* This hook wraps Next.js useRouter and automatically adds locale
+* prefixes to navigation methods.
+*
+* @returns Localized router object
+*
+* @example
+* ```tsx
+* import { useLocalizedRouter } from '@comvi/next/navigation';
+*
+* function MyComponent() {
+*   const router = useLocalizedRouter();
+*
+*   const handleClick = () => {
+*     router.push('/about'); // Navigates to /en/about (or current locale)
+*   };
+*
+*   const handleGerman = () => {
+*     router.push('/about', 'de'); // Navigates to /de/about
+*   };
+*
+*   return <button onClick={handleClick}>Go to About</button>;
+* }
+* ```
+*/
+function useLocalizedRouter() {
+	const router = useRouter();
+	const { locale } = useI18n();
+	const routing = useRoutingConfig();
+	const push = useCallback((href, targetLocale) => {
+		const localizedHref = localizeHref(href, targetLocale ?? locale, routing ?? void 0);
+		router.push(localizedHref);
+	}, [
+		router,
+		locale,
+		routing
+	]);
+	const replace = useCallback((href, targetLocale) => {
+		const localizedHref = localizeHref(href, targetLocale ?? locale, routing ?? void 0);
+		router.replace(localizedHref);
+	}, [
+		router,
+		locale,
+		routing
+	]);
+	const prefetch = useCallback((href, targetLocale) => {
+		const localizedHref = localizeHref(href, targetLocale ?? locale, routing ?? void 0);
+		router.prefetch(localizedHref);
+	}, [
+		router,
+		locale,
+		routing
+	]);
+	return {
+		push,
+		replace,
+		back: router.back,
+		forward: router.forward,
+		refresh: router.refresh,
+		prefetch
+	};
+}
+//#endregion
+export { useLocalizedRouter, usePathname$1 as usePathname };

package/dist/routing/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Locale prefix mode for URL routing
+ */
+export type LocalePrefixMode = "always" | "as-needed" | "never";
+/**
+ * Configuration for i18n routing
+ *
+ * @typeParam T - Union type of supported locale strings (e.g., 'en' | 'uk' | 'de')
+ */
+export interface RoutingConfig<T extends string = string> {
+    /** Supported locales */
+    locales: readonly T[];
+    /** Default locale */
+    defaultLocale: T;
+    /**
+     * Locale prefix mode:
+     * - 'always': All routes have locale prefix (/en/about, /de/about)
+     * - 'as-needed': Only non-default locales have prefix (/about for en, /de/about for de)
+     * - 'never': No locale prefixes (use cookie/header only)
+     * @default 'as-needed'
+     */
+    localePrefix?: LocalePrefixMode;
+    /**
+     * Cookie name for storing locale preference
+     * @default 'NEXT_LOCALE'
+     */
+    localeCookie?: string;
+    /**
+     * Path configurations for different locales (optional)
+     * Allows different URL paths per locale
+     * @example { '/about': { en: '/about', de: '/ueber-uns' } }
+     */
+    pathnames?: Record<string, Partial<Record<T, string>>>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/routing/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/routing/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,WAAW,GAAG,OAAO,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IACtD,wBAAwB;IACxB,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;IACtB,qBAAqB;IACrB,aAAa,EAAE,CAAC,CAAC;IACjB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;CACxD"}

package/dist/routing/utils.cjs

@@ -0,0 +1,94 @@
+const require_defineRouting = require("./defineRouting.cjs");
+//#region src/routing/utils.ts
+var getPathnameCache = /* @__PURE__ */ new WeakMap();
+var isExternalHref = (href) => {
+	return /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("//");
+};
+var isRelativeFragmentOrQuery = (href) => {
+	return href.startsWith("#") || href.startsWith("?");
+};
+var normalizePath = (path) => {
+	if (!path) return "/";
+	return path.startsWith("/") ? path : `/${path}`;
+};
+var getCanonicalPathMatch = (pathname, routing, preferredLocale) => {
+	const normalizedPath = normalizePath(pathname);
+	const localesToTry = preferredLocale ? [preferredLocale, ...routing.locales.filter((locale) => locale !== preferredLocale)] : [...routing.locales];
+	for (const [canonicalPath, localizedByLocale] of Object.entries(routing.pathnames)) {
+		const normalizedCanonicalPath = normalizePath(canonicalPath);
+		if (normalizedPath === normalizedCanonicalPath) return normalizedCanonicalPath;
+		for (const locale of localesToTry) {
+			const localizedPath = localizedByLocale[locale];
+			if (localizedPath && normalizePath(localizedPath) === normalizedPath) return normalizedCanonicalPath;
+		}
+	}
+};
+var stripLocalePrefix = (pathname, locales) => {
+	const normalized = normalizePath(pathname);
+	const segments = normalized.split("/").filter(Boolean);
+	if (segments.length === 0) return "/";
+	const first = segments[0];
+	if (locales.includes(first)) {
+		const rest = segments.slice(1).join("/");
+		return rest ? `/${rest}` : "/";
+	}
+	return normalized;
+};
+var getCanonicalPathname = (pathname, routing, preferredLocale) => {
+	const normalizedPath = normalizePath(pathname);
+	return getCanonicalPathMatch(normalizedPath, routing, preferredLocale) ?? normalizedPath;
+};
+var splitHref = (href) => {
+	const match = href.match(/[?#]/);
+	if (!match || match.index === void 0) return {
+		path: href,
+		suffix: ""
+	};
+	const index = match.index;
+	return {
+		path: href.slice(0, index),
+		suffix: href.slice(index)
+	};
+};
+var localizePathname = (pathname, locale, routing) => {
+	const { path, suffix } = splitHref(pathname);
+	const canonicalPath = getCanonicalPathname(stripLocalePrefix(path, routing.locales), routing, locale);
+	let getPathname = getPathnameCache.get(routing);
+	if (!getPathname) {
+		getPathname = require_defineRouting.createGetPathname(routing);
+		getPathnameCache.set(routing, getPathname);
+	}
+	return `${getPathname({
+		locale,
+		href: canonicalPath
+	})}${suffix}`;
+};
+var localizeHref = (href, locale, routing) => {
+	if (isExternalHref(href)) return href;
+	if (isRelativeFragmentOrQuery(href)) return href;
+	if (!routing) {
+		const normalized = normalizePath(href);
+		return `/${locale}${normalized === "/" ? "" : normalized}`;
+	}
+	return localizePathname(href, locale, routing);
+};
+var localizeUrlObject = (href, locale, routing) => {
+	if (href.protocol) return href;
+	const pathname = typeof href.pathname === "string" ? href.pathname : "/";
+	if (!routing) {
+		const normalized = normalizePath(pathname);
+		return {
+			...href,
+			pathname: `/${locale}${normalized === "/" ? "" : normalized}`
+		};
+	}
+	return {
+		...href,
+		pathname: localizePathname(pathname, locale, routing)
+	};
+};
+//#endregion
+exports.getCanonicalPathname = getCanonicalPathname;
+exports.localizeHref = localizeHref;
+exports.localizeUrlObject = localizeUrlObject;
+exports.stripLocalePrefix = stripLocalePrefix;

package/dist/routing/utils.d.ts

@@ -0,0 +1,8 @@
+import { UrlObject } from 'url';
+import { RoutingConfig } from './types';
+export declare const stripLocalePrefix: (pathname: string, locales: readonly string[]) => string;
+export declare const getCanonicalPathname: (pathname: string, routing: Required<RoutingConfig>, preferredLocale?: string) => string;
+export declare const localizePathname: (pathname: string, locale: string, routing: Required<RoutingConfig>) => string;
+export declare const localizeHref: (href: string, locale: string, routing?: Required<RoutingConfig>) => string;
+export declare const localizeUrlObject: (href: UrlObject, locale: string, routing?: Required<RoutingConfig>) => UrlObject;
+//# sourceMappingURL=utils.d.ts.map

package/dist/routing/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/routing/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAiD7C,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,EAAE,SAAS,SAAS,MAAM,EAAE,KAAG,MAYhF,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,UAAU,MAAM,EAChB,SAAS,QAAQ,CAAC,aAAa,CAAC,EAChC,kBAAkB,MAAM,KACvB,MAGF,CAAC;AAWF,eAAO,MAAM,gBAAgB,GAC3B,UAAU,MAAM,EAChB,QAAQ,MAAM,EACd,SAAS,QAAQ,CAAC,aAAa,CAAC,KAC/B,MAWF,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,MAAM,MAAM,EACZ,QAAQ,MAAM,EACd,UAAU,QAAQ,CAAC,aAAa,CAAC,KAChC,MAQF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,MAAM,SAAS,EACf,QAAQ,MAAM,EACd,UAAU,QAAQ,CAAC,aAAa,CAAC,KAChC,SAgBF,CAAC"}

package/dist/routing/utils.js

@@ -0,0 +1,91 @@
+import { createGetPathname } from "./defineRouting.js";
+//#region src/routing/utils.ts
+var getPathnameCache = /* @__PURE__ */ new WeakMap();
+var isExternalHref = (href) => {
+	return /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("//");
+};
+var isRelativeFragmentOrQuery = (href) => {
+	return href.startsWith("#") || href.startsWith("?");
+};
+var normalizePath = (path) => {
+	if (!path) return "/";
+	return path.startsWith("/") ? path : `/${path}`;
+};
+var getCanonicalPathMatch = (pathname, routing, preferredLocale) => {
+	const normalizedPath = normalizePath(pathname);
+	const localesToTry = preferredLocale ? [preferredLocale, ...routing.locales.filter((locale) => locale !== preferredLocale)] : [...routing.locales];
+	for (const [canonicalPath, localizedByLocale] of Object.entries(routing.pathnames)) {
+		const normalizedCanonicalPath = normalizePath(canonicalPath);
+		if (normalizedPath === normalizedCanonicalPath) return normalizedCanonicalPath;
+		for (const locale of localesToTry) {
+			const localizedPath = localizedByLocale[locale];
+			if (localizedPath && normalizePath(localizedPath) === normalizedPath) return normalizedCanonicalPath;
+		}
+	}
+};
+var stripLocalePrefix = (pathname, locales) => {
+	const normalized = normalizePath(pathname);
+	const segments = normalized.split("/").filter(Boolean);
+	if (segments.length === 0) return "/";
+	const first = segments[0];
+	if (locales.includes(first)) {
+		const rest = segments.slice(1).join("/");
+		return rest ? `/${rest}` : "/";
+	}
+	return normalized;
+};
+var getCanonicalPathname = (pathname, routing, preferredLocale) => {
+	const normalizedPath = normalizePath(pathname);
+	return getCanonicalPathMatch(normalizedPath, routing, preferredLocale) ?? normalizedPath;
+};
+var splitHref = (href) => {
+	const match = href.match(/[?#]/);
+	if (!match || match.index === void 0) return {
+		path: href,
+		suffix: ""
+	};
+	const index = match.index;
+	return {
+		path: href.slice(0, index),
+		suffix: href.slice(index)
+	};
+};
+var localizePathname = (pathname, locale, routing) => {
+	const { path, suffix } = splitHref(pathname);
+	const canonicalPath = getCanonicalPathname(stripLocalePrefix(path, routing.locales), routing, locale);
+	let getPathname = getPathnameCache.get(routing);
+	if (!getPathname) {
+		getPathname = createGetPathname(routing);
+		getPathnameCache.set(routing, getPathname);
+	}
+	return `${getPathname({
+		locale,
+		href: canonicalPath
+	})}${suffix}`;
+};
+var localizeHref = (href, locale, routing) => {
+	if (isExternalHref(href)) return href;
+	if (isRelativeFragmentOrQuery(href)) return href;
+	if (!routing) {
+		const normalized = normalizePath(href);
+		return `/${locale}${normalized === "/" ? "" : normalized}`;
+	}
+	return localizePathname(href, locale, routing);
+};
+var localizeUrlObject = (href, locale, routing) => {
+	if (href.protocol) return href;
+	const pathname = typeof href.pathname === "string" ? href.pathname : "/";
+	if (!routing) {
+		const normalized = normalizePath(pathname);
+		return {
+			...href,
+			pathname: `/${locale}${normalized === "/" ? "" : normalized}`
+		};
+	}
+	return {
+		...href,
+		pathname: localizePathname(pathname, locale, routing)
+	};
+};
+//#endregion
+export { getCanonicalPathname, localizeHref, localizeUrlObject, stripLocalePrefix };

package/dist/routing.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_defineRouting = require("./routing/defineRouting.cjs");
+exports.createGetPathname = require_defineRouting.createGetPathname;
+exports.defineRouting = require_defineRouting.defineRouting;
+exports.hasLocale = require_defineRouting.hasLocale;

package/dist/routing.d.ts

@@ -0,0 +1,4 @@
+export { defineRouting, hasLocale, createGetPathname } from './routing/defineRouting';
+export type { GetPathnameOptions } from './routing/defineRouting';
+export type { RoutingConfig, LocalePrefixMode } from './routing/types';
+//# sourceMappingURL=routing.d.ts.map

package/dist/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../src/routing.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEtF,YAAY,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/routing.js

@@ -0,0 +1,2 @@
+import { createGetPathname, defineRouting, hasLocale } from "./routing/defineRouting.js";
+export { createGetPathname, defineRouting, hasLocale };

package/dist/server/cache.cjs

@@ -0,0 +1,69 @@
+require("../_virtual/_rolldown/runtime.cjs");
+//#region src/server/cache.ts
+/**
+* Request-scoped locale storage using React cache()
+* This allows setRequestLocale() to store locale that getTranslations() can read
+*
+* React's cache() creates a per-request memoized value in Server Components,
+* allowing us to share state across the component tree without prop drilling.
+*/
+var getRequestStore = (0, require("react").cache)(() => ({ locale: void 0 }));
+/**
+* Global i18n reference (set once via setI18n)
+* This is safe because Next.js creates separate module instances for server/client
+*/
+var globalI18n;
+/**
+* Configure the global i18n instance for server-side usage
+*
+* Call this once in your i18n configuration file to make getTranslations() work.
+*
+* @param i18n - The i18n instance created with createI18n
+*
+* @example
+* ```typescript
+* // i18n/index.ts
+* import { createI18n } from '@comvi/next';
+* import { setI18n } from '@comvi/next/server';
+* import { translations } from './translations';
+*
+* export const i18n = createI18n({
+*   locale: 'en',
+*   defaultNs: 'default',
+*   translation: translations,
+* });
+*
+* // Configure for server-side usage
+* setI18n(i18n);
+* ```
+*/
+function setI18n(i18n) {
+	globalI18n = i18n;
+}
+/**
+* Get the global i18n instance
+* @internal
+*/
+function getI18nInstance() {
+	if (!globalI18n) throw new Error("[comvi/next] i18n not configured. Call setI18n(i18n) in your i18n configuration file.");
+	return globalI18n;
+}
+/**
+* Set the request locale in the cache
+* @internal
+*/
+function setRequestLocaleInternal(locale) {
+	getRequestStore().locale = locale;
+}
+/**
+* Get the request locale from cache
+* @internal
+*/
+function getRequestLocaleFromCache() {
+	return getRequestStore().locale;
+}
+//#endregion
+exports.getI18nInstance = getI18nInstance;
+exports.getRequestLocaleFromCache = getRequestLocaleFromCache;
+exports.setI18n = setI18n;
+exports.setRequestLocaleInternal = setRequestLocaleInternal;

package/dist/server/cache.d.ts

@@ -0,0 +1,42 @@
+import { I18n } from '@comvi/core';
+/**
+ * Configure the global i18n instance for server-side usage
+ *
+ * Call this once in your i18n configuration file to make getTranslations() work.
+ *
+ * @param i18n - The i18n instance created with createI18n
+ *
+ * @example
+ * ```typescript
+ * // i18n/index.ts
+ * import { createI18n } from '@comvi/next';
+ * import { setI18n } from '@comvi/next/server';
+ * import { translations } from './translations';
+ *
+ * export const i18n = createI18n({
+ *   locale: 'en',
+ *   defaultNs: 'default',
+ *   translation: translations,
+ * });
+ *
+ * // Configure for server-side usage
+ * setI18n(i18n);
+ * ```
+ */
+export declare function setI18n(i18n: I18n): void;
+/**
+ * Get the global i18n instance
+ * @internal
+ */
+export declare function getI18nInstance(): I18n;
+/**
+ * Set the request locale in the cache
+ * @internal
+ */
+export declare function setRequestLocaleInternal(locale: string): void;
+/**
+ * Get the request locale from cache
+ * @internal
+ */
+export declare function getRequestLocaleFromCache(): string | undefined;
+//# sourceMappingURL=cache.d.ts.map

package/dist/server/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/server/cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAsBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAExC;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAOtC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE7D;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,GAAG,SAAS,CAE9D"}

package/dist/server/cache.js

@@ -0,0 +1,66 @@
+import { cache } from "react";
+//#region src/server/cache.ts
+/**
+* Request-scoped locale storage using React cache()
+* This allows setRequestLocale() to store locale that getTranslations() can read
+*
+* React's cache() creates a per-request memoized value in Server Components,
+* allowing us to share state across the component tree without prop drilling.
+*/
+var getRequestStore = cache(() => ({ locale: void 0 }));
+/**
+* Global i18n reference (set once via setI18n)
+* This is safe because Next.js creates separate module instances for server/client
+*/
+var globalI18n;
+/**
+* Configure the global i18n instance for server-side usage
+*
+* Call this once in your i18n configuration file to make getTranslations() work.
+*
+* @param i18n - The i18n instance created with createI18n
+*
+* @example
+* ```typescript
+* // i18n/index.ts
+* import { createI18n } from '@comvi/next';
+* import { setI18n } from '@comvi/next/server';
+* import { translations } from './translations';
+*
+* export const i18n = createI18n({
+*   locale: 'en',
+*   defaultNs: 'default',
+*   translation: translations,
+* });
+*
+* // Configure for server-side usage
+* setI18n(i18n);
+* ```
+*/
+function setI18n(i18n) {
+	globalI18n = i18n;
+}
+/**
+* Get the global i18n instance
+* @internal
+*/
+function getI18nInstance() {
+	if (!globalI18n) throw new Error("[comvi/next] i18n not configured. Call setI18n(i18n) in your i18n configuration file.");
+	return globalI18n;
+}
+/**
+* Set the request locale in the cache
+* @internal
+*/
+function setRequestLocaleInternal(locale) {
+	getRequestStore().locale = locale;
+}
+/**
+* Get the request locale from cache
+* @internal
+*/
+function getRequestLocaleFromCache() {
+	return getRequestStore().locale;
+}
+//#endregion
+export { getI18nInstance, getRequestLocaleFromCache, setI18n, setRequestLocaleInternal };

package/dist/server/ensureInitialized.cjs

@@ -0,0 +1,19 @@
+//#region src/server/ensureInitialized.ts
+var initPromises = /* @__PURE__ */ new WeakMap();
+/**
+* Ensure i18n instance is initialized, deduplicating concurrent calls.
+* @internal
+*/
+var ensureInitialized = async (i18n) => {
+	if (i18n.isInitialized) return;
+	let initPromise = initPromises.get(i18n);
+	if (!initPromise) {
+		initPromise = i18n.init().then(() => void 0).finally(() => {
+			if (initPromises.get(i18n) === initPromise) initPromises.delete(i18n);
+		});
+		initPromises.set(i18n, initPromise);
+	}
+	await initPromise;
+};
+//#endregion
+exports.ensureInitialized = ensureInitialized;

package/dist/server/ensureInitialized.d.ts

@@ -0,0 +1,7 @@
+import { I18n } from '@comvi/core';
+/**
+ * Ensure i18n instance is initialized, deduplicating concurrent calls.
+ * @internal
+ */
+export declare const ensureInitialized: (i18n: I18n) => Promise<void>;
+//# sourceMappingURL=ensureInitialized.d.ts.map

package/dist/server/ensureInitialized.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureInitialized.d.ts","sourceRoot":"","sources":["../../src/server/ensureInitialized.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAIxC;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAU,MAAM,IAAI,KAAG,OAAO,CAAC,IAAI,CAmBhE,CAAC"}

package/dist/server/ensureInitialized.js

@@ -0,0 +1,19 @@
+//#region src/server/ensureInitialized.ts
+var initPromises = /* @__PURE__ */ new WeakMap();
+/**
+* Ensure i18n instance is initialized, deduplicating concurrent calls.
+* @internal
+*/
+var ensureInitialized = async (i18n) => {
+	if (i18n.isInitialized) return;
+	let initPromise = initPromises.get(i18n);
+	if (!initPromise) {
+		initPromise = i18n.init().then(() => void 0).finally(() => {
+			if (initPromises.get(i18n) === initPromise) initPromises.delete(i18n);
+		});
+		initPromises.set(i18n, initPromise);
+	}
+	await initPromise;
+};
+//#endregion
+export { ensureInitialized };