@translation-cms/sync 1.2.28 → 1.2.30

package/dist/scaffold/intenrals/scaffold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold.js","sourceRoot":"","sources":["../../../src/scaffold/intenrals/scaffold.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EACH,WAAW,EACX,QAAQ,EACR,SAAS,EACT,SAAS,EACT,YAAY,EACZ,gBAAgB,GACnB,MAAM,gBAAgB,CAAC;AAGxB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CAAC,IAAqB;IAC9C,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG,KAAK,EAAE,GAAG,IAAI,CAAC;IAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IAEpD,qEAAqE;IACrE,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE5C,MAAM,KAAK,GAA4C;QACnD,EAAE,GAAG,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW,EAAE;QAC5C,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE;QACtC,EAAE,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE;QACxC,EAAE,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE;QACxC,EAAE,GAAG,EAAE,cAAc,EAAE,OAAO,EAAE,YAAY,EAAE;QAC9C,EAAE,GAAG,EAAE,sBAAsB,EAAE,OAAO,EAAE,gBAAgB,EAAE;QAC1D,EAAE,GAAG,EAAE,sBAAsB,EAAE,OAAO,EAAE,gBAAgB,EAAE;KAC7D,CAAC;IAEF,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,MAAM,OAAO,GAAa,EAAE,CAAC;IAE7B,KAAK,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,KAAK,EAAE,CAAC;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;QACpC,gFAAgF;QAChF,IAAI,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACnC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAClB,SAAS;QACb,CAAC;QACD,EAAE,CAAC,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACxC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtB,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AAChC,CAAC"}

package/dist/scaffold/intenrals/templates.d.ts

@@ -0,0 +1,10 @@
+/**
+ * i18n file templates.
+ */
+export declare const SETTINGS_TS = "import type { InitOptions } from 'i18next';\n\n// These imports resolve after running: sync-translations pull\nimport en from './dictionaries/en.json';\nimport type nl from './dictionaries/nl.json';\n\nexport const fallbackLng = 'nl' as const;\nexport const languages = ['nl', 'en'] as const;\nexport const defaultNS = 'common' as const;\nexport const cookieName = 'i18next';\n\nexport type Locale = (typeof languages)[number];\n\nexport const allNamespaces = Object.keys(\n    en\n) as readonly (keyof typeof en)[];\n\nexport type Dicts = {\n    en: typeof en;\n    nl: typeof nl;\n};\n\n// Re-export for convenience\nexport type { AppNamespace, Namespace } from './types';\n\nexport function getOptions(\n    lng: string = fallbackLng,\n    ns: string | readonly string[] = allNamespaces\n): InitOptions {\n    return {\n        supportedLngs: [...languages],\n        fallbackLng: lng,\n        lng,\n        fallbackNS: defaultNS,\n        defaultNS,\n        ns,\n        resources: {},\n        partialBundledLanguages: true,\n        interpolation: {\n            escapeValue: false,\n        },\n    };\n}\n";
+export declare const TYPES_TS = "import type { allNamespaces, Dicts, languages } from './settings';\n\nexport type Locale = (typeof languages)[number];\nexport type AppNamespace = (typeof allNamespaces)[number];\nexport type Namespace = AppNamespace | readonly AppNamespace[];\n\ntype PluralSuffix = '_zero' | '_one' | '_two' | '_few' | '_many' | '_other';\n\ntype StripPluralSuffix<K extends string> =\n    K extends `${infer Base}${PluralSuffix}` ? Base : K;\n\nexport type LeafPaths<T> = T extends {\n    [key: string]: string | number | boolean | null | object;\n}\n    ? {\n          [K in keyof T & string]: T[K] extends\n              | string\n              | number\n              | boolean\n              | null\n              ? K | StripPluralSuffix<K>\n              : T[K] extends object\n                ? `${K}.${LeafPaths<T[K]> & string}`\n                : never;\n      }[keyof T & string]\n    : never;\n\nexport type I18nKey = {\n    [Lang in keyof Dicts]: {\n        [Ns in keyof Dicts[Lang]]: `${Ns & string}:${LeafPaths<Dicts[Lang][Ns]> & string}`;\n    }[keyof Dicts[Lang]];\n}[keyof Dicts];\n\nexport type TranslationKey<\n    Ns extends AppNamespace | readonly AppNamespace[] | undefined = undefined,\n> = Ns extends undefined\n    ? I18nKey\n    : Ns extends readonly (infer N extends AppNamespace)[]\n      ? `${N}:${LeafPaths<Dicts['en'][N]> & string}`\n      : Ns extends AppNamespace\n        ? `${Ns}:${LeafPaths<Dicts['en'][Ns]> & string}`\n        : never;\n\nexport type TranslationKeys<\n    Ns extends AppNamespace | readonly AppNamespace[] | undefined,\n> = (key: TranslationKey<Ns>, options?: any) => string;\n";
+export declare const CLIENT_TS = "'use client';\n\nimport { useCallback } from 'react';\nimport {\n    initReactI18next,\n    Trans,\n    useTranslation as useTranslationOrg,\n    type UseTranslationOptions,\n} from 'react-i18next';\n\nexport { Trans };\n\nimport i18next, { type i18n as I18nInstance, type TOptions } from 'i18next';\n\nimport en from './dictionaries/en.json';\nimport nl from './dictionaries/nl.json';\n\nimport {\n    getOptions,\n    type AppNamespace,\n    type Locale,\n} from './settings';\nimport type { TranslationKeys } from './types';\n\nconst resources = { en, nl } as const;\n\ntype StringTOptions = Omit<TOptions, 'returnDetails' | 'returnObjects'>;\n\nlet i18nInstance: I18nInstance | null = null;\n\nexport async function initI18nClient(locale: Locale): Promise<I18nInstance> {\n    if (i18nInstance) {\n        if (i18nInstance.language !== locale) {\n            await i18nInstance.changeLanguage(locale);\n        }\n        return i18nInstance;\n    }\n\n    i18nInstance = i18next.createInstance();\n\n    await i18nInstance.use(initReactI18next).init({\n        ...getOptions(locale),\n        resources,\n    });\n\n    return i18nInstance;\n}\n\nexport function useTranslation<\n    Ns extends AppNamespace | readonly AppNamespace[],\n>(ns: Ns, hookOptions?: UseTranslationOptions<undefined>) {\n    const namespacesToLoad: AppNamespace[] = Array.isArray(ns)\n        ? [...ns]\n        : ns\n          ? [ns]\n          : [];\n\n    const result = useTranslationOrg(namespacesToLoad, hookOptions);\n    const { t: tOrg } = result;\n\n    const tBase = useCallback(\n        (key: string, tOptions?: StringTOptions): string => {\n            return tOrg(key, {\n                ...tOptions,\n                returnDetails: false,\n                returnObjects: false,\n            } as TOptions) as string;\n        },\n        [tOrg]\n    );\n\n    const t = tBase as TranslationKeys<Ns>;\n    const tDynamic = tBase;\n\n    return {\n        ...result,\n        t,\n        tDynamic,\n    };\n}\n";
+export declare const SERVER_TS = "import { initReactI18next } from 'react-i18next/initReactI18next';\nimport { cookies, headers } from 'next/headers';\nimport { createInstance, type TOptions } from 'i18next';\nimport resourcesToBackend from 'i18next-resources-to-backend';\n\nimport {\n    cookieName,\n    fallbackLng,\n    getOptions,\n    languages,\n    type Locale,\n} from './settings';\nimport type { AppNamespace, I18nKey, TranslationKeys } from './types';\n\ntype StringTOptions = Omit<TOptions, 'returnDetails' | 'returnObjects'>;\n\nexport async function initI18n(locale: string) {\n    const i18n = createInstance();\n\n    await i18n\n        .use(initReactI18next)\n        .use(\n            resourcesToBackend((language: string, namespace: string) =>\n                import(`./dictionaries/${language}.json`).then(module => {\n                    return (module.default as Record<string, unknown>)[namespace] ?? {};\n                })\n            )\n        )\n        .init(getOptions(locale, []));\n\n    return i18n;\n}\n\nexport async function getTranslation<\n    Ns extends AppNamespace | readonly AppNamespace[],\n>(ns: Ns, options: { keyPrefix?: string } = {}) {\n    const lng = await getLocale();\n    const i18n = await initI18n(lng);\n\n    const namespacesToLoad: readonly AppNamespace[] = ns\n        ? Array.isArray(ns)\n            ? ns\n            : [ns]\n        : [];\n\n    if (namespacesToLoad.length > 0) {\n        await i18n.loadNamespaces(namespacesToLoad);\n    }\n\n    const fixedT = i18n.getFixedT(lng, namespacesToLoad, options.keyPrefix);\n\n    const t = (key: I18nKey, tOptions?: StringTOptions): string => {\n        return fixedT(key, {\n            ...tOptions,\n            returnDetails: false,\n            returnObjects: false,\n        } as TOptions) as string;\n    };\n\n    return {\n        t: t as TranslationKeys<Ns>,\n        tDynamic: t,\n        i18n,\n    };\n}\n\nexport async function getLocale(): Promise<Locale> {\n    const isSupportedLocale = (value: string): value is Locale =>\n        (languages as readonly string[]).includes(value);\n\n    try {\n        const cookieStore = await cookies();\n        const localeCookie = cookieStore.get(cookieName);\n        if (localeCookie?.value && isSupportedLocale(localeCookie.value)) {\n            return localeCookie.value;\n        }\n\n        const headersList = await headers();\n        const acceptLanguage = headersList.get('accept-language') ?? '';\n        const supported = new Set(\n            (languages as readonly string[]).map(l => l.toLowerCase())\n        );\n\n        const preferences = acceptLanguage\n            .split(',')\n            .map((part): { code: string; q: number } | null => {\n                const trimmed = part.trim();\n                if (!trimmed) return null;\n                const [tag = '', qPartRaw] = trimmed.split(';');\n                const qPart = qPartRaw?.trim();\n                const q = qPart?.startsWith('q=') ? Number(qPart.slice(2)) : 1;\n                const code = (tag.trim().split('-')[0] ?? '').toLowerCase();\n                if (!code || !Number.isFinite(q) || q <= 0 || q > 1) return null;\n                return { code, q };\n            })\n            .filter((x): x is { code: string; q: number } => x !== null)\n            .sort((a, b) => b.q - a.q);\n\n        const best = preferences.find(x => supported.has(x.code));\n        if (best) return best.code as Locale;\n    } catch {\n        // cookies()/headers() unavailable at build time\n    }\n\n    return fallbackLng;\n}\n";
+export declare const PROVIDER_TSX = "'use client';\n\nimport { useEffect, useState } from 'react';\nimport { I18nextProvider } from 'react-i18next';\nimport type { i18n as I18nInstance } from 'i18next';\n\nimport { initI18nClient } from './client';\nimport { cookieName, type Locale } from './settings';\n\ninterface TranslationProviderProps {\n    children: React.ReactNode;\n    locale: Locale;\n}\n\n/**\n * Root provider for i18n. Add to your root layout:\n *\n * ```tsx\n * import { TranslationProvider } from '@/lib/i18n/provider';\n * import { getLocale } from '@/lib/i18n/server';\n *\n * export default async function RootLayout({ children }) {\n *     const locale = await getLocale();\n *     return (\n *         <html lang={locale}>\n *             <body>\n *                 <TranslationProvider locale={locale}>\n *                     {children}\n *                 </TranslationProvider>\n *             </body>\n *         </html>\n *     );\n * }\n * ```\n */\nexport function TranslationProvider({ children, locale }: TranslationProviderProps) {\n    const [i18n, setI18n] = useState<I18nInstance | null>(null);\n\n    useEffect(() => {\n        initI18nClient(locale).then(setI18n);\n    }, [locale]);\n\n    useEffect(() => {\n        if (!i18n) return;\n        const handleLanguageChanged = (lng: string) => {\n            document.documentElement.lang = lng;\n            const expires = new Date();\n            expires.setFullYear(expires.getFullYear() + 1);\n            document.cookie = `${cookieName}=${encodeURIComponent(lng)}; expires=${expires.toUTCString()}; path=/; SameSite=Lax`;\n        };\n        handleLanguageChanged(i18n.language);\n        i18n.on('languageChanged', handleLanguageChanged);\n        return () => { i18n.off('languageChanged', handleLanguageChanged); };\n    }, [i18n]);\n\n    if (!i18n) return null;\n\n    return <I18nextProvider i18n={i18n}>{children}</I18nextProvider>;\n}\n";
+export declare const PLACEHOLDER_DICT: string;
+//# sourceMappingURL=templates.d.ts.map

package/dist/scaffold/intenrals/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../../src/scaffold/intenrals/templates.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,WAAW,gmCA2CvB,CAAC;AAEF,eAAO,MAAM,QAAQ,qlDA8CpB,CAAC;AAEF,eAAO,MAAM,SAAS,09DAgFrB,CAAC;AAEF,eAAO,MAAM,SAAS,k+GA0GrB,CAAC;AAEF,eAAO,MAAM,YAAY,o3DA2DxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAA0C,CAAC"}

package/dist/scaffold/intenrals/templates.js

@@ -0,0 +1,344 @@
+/**
+ * i18n file templates.
+ */
+export const SETTINGS_TS = `import type { InitOptions } from 'i18next';
+
+// These imports resolve after running: sync-translations pull
+import en from './dictionaries/en.json';
+import type nl from './dictionaries/nl.json';
+
+export const fallbackLng = 'nl' as const;
+export const languages = ['nl', 'en'] as const;
+export const defaultNS = 'common' as const;
+export const cookieName = 'i18next';
+
+export type Locale = (typeof languages)[number];
+
+export const allNamespaces = Object.keys(
+    en
+) as readonly (keyof typeof en)[];
+
+export type Dicts = {
+    en: typeof en;
+    nl: typeof nl;
+};
+
+// Re-export for convenience
+export type { AppNamespace, Namespace } from './types';
+
+export function getOptions(
+    lng: string = fallbackLng,
+    ns: string | readonly string[] = allNamespaces
+): InitOptions {
+    return {
+        supportedLngs: [...languages],
+        fallbackLng: lng,
+        lng,
+        fallbackNS: defaultNS,
+        defaultNS,
+        ns,
+        resources: {},
+        partialBundledLanguages: true,
+        interpolation: {
+            escapeValue: false,
+        },
+    };
+}
+`;
+export const TYPES_TS = `import type { allNamespaces, Dicts, languages } from './settings';
+
+export type Locale = (typeof languages)[number];
+export type AppNamespace = (typeof allNamespaces)[number];
+export type Namespace = AppNamespace | readonly AppNamespace[];
+
+type PluralSuffix = '_zero' | '_one' | '_two' | '_few' | '_many' | '_other';
+
+type StripPluralSuffix<K extends string> =
+    K extends \`\${infer Base}\${PluralSuffix}\` ? Base : K;
+
+export type LeafPaths<T> = T extends {
+    [key: string]: string | number | boolean | null | object;
+}
+    ? {
+          [K in keyof T & string]: T[K] extends
+              | string
+              | number
+              | boolean
+              | null
+              ? K | StripPluralSuffix<K>
+              : T[K] extends object
+                ? \`\${K}.\${LeafPaths<T[K]> & string}\`
+                : never;
+      }[keyof T & string]
+    : never;
+
+export type I18nKey = {
+    [Lang in keyof Dicts]: {
+        [Ns in keyof Dicts[Lang]]: \`\${Ns & string}:\${LeafPaths<Dicts[Lang][Ns]> & string}\`;
+    }[keyof Dicts[Lang]];
+}[keyof Dicts];
+
+export type TranslationKey<
+    Ns extends AppNamespace | readonly AppNamespace[] | undefined = undefined,
+> = Ns extends undefined
+    ? I18nKey
+    : Ns extends readonly (infer N extends AppNamespace)[]
+      ? \`\${N}:\${LeafPaths<Dicts['en'][N]> & string}\`
+      : Ns extends AppNamespace
+        ? \`\${Ns}:\${LeafPaths<Dicts['en'][Ns]> & string}\`
+        : never;
+
+export type TranslationKeys<
+    Ns extends AppNamespace | readonly AppNamespace[] | undefined,
+> = (key: TranslationKey<Ns>, options?: any) => string;
+`;
+export const CLIENT_TS = `'use client';
+
+import { useCallback } from 'react';
+import {
+    initReactI18next,
+    Trans,
+    useTranslation as useTranslationOrg,
+    type UseTranslationOptions,
+} from 'react-i18next';
+
+export { Trans };
+
+import i18next, { type i18n as I18nInstance, type TOptions } from 'i18next';
+
+import en from './dictionaries/en.json';
+import nl from './dictionaries/nl.json';
+
+import {
+    getOptions,
+    type AppNamespace,
+    type Locale,
+} from './settings';
+import type { TranslationKeys } from './types';
+
+const resources = { en, nl } as const;
+
+type StringTOptions = Omit<TOptions, 'returnDetails' | 'returnObjects'>;
+
+let i18nInstance: I18nInstance | null = null;
+
+export async function initI18nClient(locale: Locale): Promise<I18nInstance> {
+    if (i18nInstance) {
+        if (i18nInstance.language !== locale) {
+            await i18nInstance.changeLanguage(locale);
+        }
+        return i18nInstance;
+    }
+
+    i18nInstance = i18next.createInstance();
+
+    await i18nInstance.use(initReactI18next).init({
+        ...getOptions(locale),
+        resources,
+    });
+
+    return i18nInstance;
+}
+
+export function useTranslation<
+    Ns extends AppNamespace | readonly AppNamespace[],
+>(ns: Ns, hookOptions?: UseTranslationOptions<undefined>) {
+    const namespacesToLoad: AppNamespace[] = Array.isArray(ns)
+        ? [...ns]
+        : ns
+          ? [ns]
+          : [];
+
+    const result = useTranslationOrg(namespacesToLoad, hookOptions);
+    const { t: tOrg } = result;
+
+    const tBase = useCallback(
+        (key: string, tOptions?: StringTOptions): string => {
+            return tOrg(key, {
+                ...tOptions,
+                returnDetails: false,
+                returnObjects: false,
+            } as TOptions) as string;
+        },
+        [tOrg]
+    );
+
+    const t = tBase as TranslationKeys<Ns>;
+    const tDynamic = tBase;
+
+    return {
+        ...result,
+        t,
+        tDynamic,
+    };
+}
+`;
+export const SERVER_TS = `import { initReactI18next } from 'react-i18next/initReactI18next';
+import { cookies, headers } from 'next/headers';
+import { createInstance, type TOptions } from 'i18next';
+import resourcesToBackend from 'i18next-resources-to-backend';
+
+import {
+    cookieName,
+    fallbackLng,
+    getOptions,
+    languages,
+    type Locale,
+} from './settings';
+import type { AppNamespace, I18nKey, TranslationKeys } from './types';
+
+type StringTOptions = Omit<TOptions, 'returnDetails' | 'returnObjects'>;
+
+export async function initI18n(locale: string) {
+    const i18n = createInstance();
+
+    await i18n
+        .use(initReactI18next)
+        .use(
+            resourcesToBackend((language: string, namespace: string) =>
+                import(\`./dictionaries/\${language}.json\`).then(module => {
+                    return (module.default as Record<string, unknown>)[namespace] ?? {};
+                })
+            )
+        )
+        .init(getOptions(locale, []));
+
+    return i18n;
+}
+
+export async function getTranslation<
+    Ns extends AppNamespace | readonly AppNamespace[],
+>(ns: Ns, options: { keyPrefix?: string } = {}) {
+    const lng = await getLocale();
+    const i18n = await initI18n(lng);
+
+    const namespacesToLoad: readonly AppNamespace[] = ns
+        ? Array.isArray(ns)
+            ? ns
+            : [ns]
+        : [];
+
+    if (namespacesToLoad.length > 0) {
+        await i18n.loadNamespaces(namespacesToLoad);
+    }
+
+    const fixedT = i18n.getFixedT(lng, namespacesToLoad, options.keyPrefix);
+
+    const t = (key: I18nKey, tOptions?: StringTOptions): string => {
+        return fixedT(key, {
+            ...tOptions,
+            returnDetails: false,
+            returnObjects: false,
+        } as TOptions) as string;
+    };
+
+    return {
+        t: t as TranslationKeys<Ns>,
+        tDynamic: t,
+        i18n,
+    };
+}
+
+export async function getLocale(): Promise<Locale> {
+    const isSupportedLocale = (value: string): value is Locale =>
+        (languages as readonly string[]).includes(value);
+
+    try {
+        const cookieStore = await cookies();
+        const localeCookie = cookieStore.get(cookieName);
+        if (localeCookie?.value && isSupportedLocale(localeCookie.value)) {
+            return localeCookie.value;
+        }
+
+        const headersList = await headers();
+        const acceptLanguage = headersList.get('accept-language') ?? '';
+        const supported = new Set(
+            (languages as readonly string[]).map(l => l.toLowerCase())
+        );
+
+        const preferences = acceptLanguage
+            .split(',')
+            .map((part): { code: string; q: number } | null => {
+                const trimmed = part.trim();
+                if (!trimmed) return null;
+                const [tag = '', qPartRaw] = trimmed.split(';');
+                const qPart = qPartRaw?.trim();
+                const q = qPart?.startsWith('q=') ? Number(qPart.slice(2)) : 1;
+                const code = (tag.trim().split('-')[0] ?? '').toLowerCase();
+                if (!code || !Number.isFinite(q) || q <= 0 || q > 1) return null;
+                return { code, q };
+            })
+            .filter((x): x is { code: string; q: number } => x !== null)
+            .sort((a, b) => b.q - a.q);
+
+        const best = preferences.find(x => supported.has(x.code));
+        if (best) return best.code as Locale;
+    } catch {
+        // cookies()/headers() unavailable at build time
+    }
+
+    return fallbackLng;
+}
+`;
+export const PROVIDER_TSX = `'use client';
+
+import { useEffect, useState } from 'react';
+import { I18nextProvider } from 'react-i18next';
+import type { i18n as I18nInstance } from 'i18next';
+
+import { initI18nClient } from './client';
+import { cookieName, type Locale } from './settings';
+
+interface TranslationProviderProps {
+    children: React.ReactNode;
+    locale: Locale;
+}
+
+/**
+ * Root provider for i18n. Add to your root layout:
+ *
+ * \`\`\`tsx
+ * import { TranslationProvider } from '@/lib/i18n/provider';
+ * import { getLocale } from '@/lib/i18n/server';
+ *
+ * export default async function RootLayout({ children }) {
+ *     const locale = await getLocale();
+ *     return (
+ *         <html lang={locale}>
+ *             <body>
+ *                 <TranslationProvider locale={locale}>
+ *                     {children}
+ *                 </TranslationProvider>
+ *             </body>
+ *         </html>
+ *     );
+ * }
+ * \`\`\`
+ */
+export function TranslationProvider({ children, locale }: TranslationProviderProps) {
+    const [i18n, setI18n] = useState<I18nInstance | null>(null);
+
+    useEffect(() => {
+        initI18nClient(locale).then(setI18n);
+    }, [locale]);
+
+    useEffect(() => {
+        if (!i18n) return;
+        const handleLanguageChanged = (lng: string) => {
+            document.documentElement.lang = lng;
+            const expires = new Date();
+            expires.setFullYear(expires.getFullYear() + 1);
+            document.cookie = \`\${cookieName}=\${encodeURIComponent(lng)}; expires=\${expires.toUTCString()}; path=/; SameSite=Lax\`;
+        };
+        handleLanguageChanged(i18n.language);
+        i18n.on('languageChanged', handleLanguageChanged);
+        return () => { i18n.off('languageChanged', handleLanguageChanged); };
+    }, [i18n]);
+
+    if (!i18n) return null;
+
+    return <I18nextProvider i18n={i18n}>{children}</I18nextProvider>;
+}
+`;
+export const PLACEHOLDER_DICT = JSON.stringify({ common: {} }, null, 4);
+//# sourceMappingURL=templates.js.map

package/dist/scaffold/intenrals/templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.js","sourceRoot":"","sources":["../../../src/scaffold/intenrals/templates.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2C1B,CAAC;AAEF,MAAM,CAAC,MAAM,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CvB,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgFxB,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0GxB,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2D3B,CAAC;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC"}

package/dist/scaffold/intenrals/types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Types for i18n scaffolding.
+ */
+export interface ScaffoldOptions {
+    /** Absolute path to the i18n directory, e.g. /project/src/lib/i18n */
+    i18nDir: string;
+    /** Whether to overwrite existing files */
+    overwrite?: boolean;
+}
+export interface ScaffoldResult {
+    written: string[];
+    skipped: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/scaffold/intenrals/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/scaffold/intenrals/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,eAAe;IAC5B,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC3B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACrB"}

package/dist/scaffold/intenrals/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for i18n scaffolding.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/scaffold/intenrals/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/scaffold/intenrals/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@translation-cms/sync",
-    "version": "1.2.28",
+    "version": "1.2.30",
     "description": "Scan translation keys in your codebase and sync them to the Translations CMS",
     "type": "module",
     "main": "./dist/index.js",
@@ -33,10 +33,10 @@
         "next.d.ts"
     ],
     "scripts": {
-        "build": "tsc && tsc-alias",
+        "build": "rm -rf dist tsconfig.tsbuildinfo && tsc && tsc-alias",
         "dev": "tsc --watch",
         "typecheck": "tsc --noEmit",
-        "release": "rm -rf dist && pnpm build && npm version patch && npm publish"
+        "release": "pnpm build && npm version patch && npm publish"
     },
     "keywords": [
         "translations",