App Router ಬಳಸಿ Next.js ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಅಂತಾರಾಷ್ಟ್ರೀಯಿಕರಣವನ್ನು ಹೇಗೆ ಅನುಷ್ಟಾನಗೊಳಿಸುವುದು

ನಿಮ್ಮ React ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಇನ್ನಷ್ಟು ಪ್ರವೇಶೋದ್ದೇಶಿ ಮಾಡಿ ಮತ್ತು ಅಂತರರಾಷ್ಟ್ರೀಯೀಕರಣ (i18n) ಮೂಲಕ ಹೊಸ ಮಾರುಕಟ್ಟೆಗಳನ್ನು ತಲುಪಿರಿ.

ಪ್ರಪಂಚ ಹೆಚ್ಚಾಗಿ ಜಾಗತೀಕರಣಗೊಂಡಂತೆ, ವಿಭಿನ್ನ ದೇಶಗಳು ಮತ್ತು ಸಂಸ್ಕೃತಿಗಳ ಬಳಕೆದಾರರನ್ನು ಪೂರೈಸುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ವೆಬ್ ಡೆವೆಲಪರ್‌ಗಳು ನಿರ್ಮಿಸುವುದು ngày càng ಮುಖ್ಯವಾಗುತ್ತಿದೆ. ಇದನ್ನು ಸಾಧಿಸುವ ಪ್ರಮುಖ ಮಾರ್ಗಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಅಂತಾರಾಷ್ಟ್ರೀಯೀಕರಣ (i18n), ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ವಿಭಿನ್ನ ಭಾಷೆಗಳು, ಕರೆನ್ಸಿಗಳು ಮತ್ತು ದಿನಾಂಕ ಸ್ವರೂಪಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳಲು ಅನುಮತಿಸುತ್ತದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು ನಿಮ್ಮ React Next.js ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಸರ್ವರ್ ಸೈಡ್ ರೆಂಡರಿಂಗ್ ಸಹಿತ ಅಂತಾರಾಷ್ಟ್ರೀಯೀಕರಣವನ್ನು ಹೇಗೆ ಸೇರಿಸಬಹುದೆಂದು ಅನ್ವೇಷಿಸೋಣ. TL;DR: ಪೂರ್ಣ ಉದಾಹರಣೆಯನ್ನು ಇಲ್ಲಿ ನೋಡಿ.

ಈ ಮಾರ್ಗದರ್ಶಿ App Router ಬಳಸುತ್ತಿರುವ Next.js ಅನ್ವಯಿಕೆಗಳಿಗೆ арналған.
ನೀವು Pages Router ಬಳಸುತ್ತಿದ್ದರೆ, ಬದಲಾಗಿ ಈ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ನೋಡಿ.

ಹಂತ 1: i18n ಲೈಬ್ರರಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ

ನಿಮ್ಮ Next.js ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಅಂತರರಾಷ್ಟ್ರೀಯೀಕರಣವನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಲು, ನಾವು ಮೊದಲು i18n ಲೈಬ್ರರಿ ಆಯ್ಕೆಮಾಡುತ್ತೇವೆ. ಅನೇಕ ಜನಪ್ರಿಯ ಲೈಬ್ರರಿಗಳು உள்ளವು, ಅವುಗಳಲ್ಲಿ next-intl ಸಹ ಇದೆ. ಆದರೆ ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು TacoTranslate ಬಳಸಲಿದ್ದೇವೆ.

TacoTranslate ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಅತ್ಯಾಧುನಿಕ AI ಬಳಸಿ ಯಾವುದೇ ಭಾಷೆಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅನುವಾದಿಸುತ್ತದೆ, ಹಾಗೆಯೇ JSON ಫೈಲ್‌ಗಳ ಕುರುಡು ನಿರ್ವಹಣೆಯಿಂದ ನಿಮ್ಮನ್ನು ಮುಕ್ತಮಾಡುತ್ತದೆ.

ನಿಮ್ಮ ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ npm ಬಳಸಿ ಇದನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡೋಣ:

npm install tacotranslate

ಹಂತ 2: ಉಚಿತ TacoTranslate ಖಾತೆಯನ್ನು ಸೃಷ್ಟಿಸಿ

ನೀವು ಈಗಾಗಲೇ ಮೋ듳್ಯೂಲ್ ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿದ್ದಾರೆ, ಆಗಿ ನಿಮ್ಮ TacoTranslate ಖಾತೆ, ಒಂದು ಅನುವಾದ ಯೋಜನೆ ಮತ್ತು ಸಂಬಂಧಿತ API ಕೀಗಳನ್ನು ಸೃಷ್ಟಿಸುವ ಸಮಯ ಬಂದಿದೆ. ಇಲ್ಲಿ ಖಾತೆಯನ್ನು ಸೃಷ್ಟಿಸಿ. ಇದು ಉಚಿತವಾಗಿದೆ, ಮತ್ತು ನೀವು ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಸೇರಿಸಲು ಅಗತ್ಯವಿಲ್ಲ.

TacoTranslate ಅಪ್ಲಿಕೇಶನ್ UI ಒಳಗೆ, ಒಂದು ಪ್ರಾಜೆಕ್ಟ್ ರಚಿಸಿ, ಮತ್ತು ಅದಿನ API ಕೀಸ್ ಟ್ಯಾಬ್ ಗೆ ನವಿಗೇಟ್ ಮಾಡಿ. ಒಂದೊಂದು read ಕೀ ಮತ್ತು ಒಂದು read/write ಕೀ ರಚಿಸಿ. ಅವುಗಳನ್ನು ನಾವು ಪರಿಸರ ಚರ (environment variables) ಆಗಿ ಉಳಿಸುವೆವು. read ಕೀ ಅನ್ನು ನಾವು public ಎಂದು ಕರೆಯುತ್ತೇವೆ ಮತ್ತು read/write ಕೀ ಅನ್ನು secret ಎಂದು ಕರೆಯುತ್ತಾರೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಅವುಗಳನ್ನು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಮೂಲದಲ್ಲಿ ಇರುವ .env ಫೈಲ್‌ಗೆ ಸೇರಿಸಬಹುದು.

.env

TACOTRANSLATE_PUBLIC_API_KEY=123456
TACOTRANSLATE_SECRET_API_KEY=789010

ರಹಸ್ಯ read/write API ಕೀವನ್ನು ಕ್ಲೈಂಟ್ ಸೈಡ್ ಉತ್ಪಾದನಾ ಪರಿಸರಗಳಿಗೆ ಎಂದಿಗೂ ಲೀಕ್ ಮಾಡಬೇಡಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ನಾವು ಮತ್ತೂ ಎರಡು ಪರಿಸರ ಚರಗಳನ್ನು ಸೇರಿಸೋಣ: TACOTRANSLATE_DEFAULT_LOCALE ಮತ್ತು TACOTRANSLATE_ORIGIN.

TACOTRANSLATE_DEFAULT_LOCALE: ಡೀಫಾಲ್ಟ್Fallback Locale ಕೋಡ್. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಅದನ್ನು en ಎನಗ್ಲಿಷ್ ನಿಗೂಡಿಸಲು ಹೊಂದಿಸುವೆವು.
TACOTRANSLATE_ORIGIN: ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಸಂಗ್ರಹಿಸಲಾಗುವ “ಫೋಲ್ಡರ್”, ಉದಾಹರಣೆಗೆ ನಿಮ್ಮ ವೆಬ್‌ಸೈಟ್‌ನ URL. ಇಲ್ಲಿ ಮೂಲಗಳ ಕುರಿತು وڌيڪ ಓದಿ.

.env

TACOTRANSLATE_DEFAULT_LOCALE=en
TACOTRANSLATE_ORIGIN=your-website-url.com

ಹಂತ 3: TacoTranslate ಅನ್ನು ಸೆಟ್ ಅಪ್ ಮಾಡುವುದು

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ದಲ್ಲಿ TacoTranslate ಅನ್ನು ಸಂಯೋಜಿಸಲು, ಹಿಂದಿನ API ಕೀಲಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದು ಕ್ಲೈಯಂಟ್ ಅನ್ನು ರಚಿಸಬೇಕಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, /tacotranslate-client.js ಎಂಬ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ.

/tacotranslate-client.js

const {default: createTacoTranslateClient} = require('tacotranslate');

const tacoTranslate = createTacoTranslateClient({
	apiKey:
		process.env.TACOTRANSLATE_SECRET_API_KEY ??
		process.env.TACOTRANSLATE_PUBLIC_API_KEY ??
		process.env.TACOTRANSLATE_API_KEY,
	projectLocale:
		process.env.TACOTRANSLATE_IS_PRODUCTION === 'true'
			? process.env.TACOTRANSLATE_PROJECT_LOCALE
			: undefined,
});

module.exports = tacoTranslate;

ನಾವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ TACOTRANSLATE_API_KEY ಮತ್ತು TACOTRANSLATE_PROJECT_LOCALE ಅನ್ನು ಶೀಘ್ರದಲ್ಲೇ ನಿರ್ವಚಿಸುವೆವು.

ಕ್ಲೈಂಟ್ ಅನ್ನು ಬೇರೆ ಫೈಲ್‌ನಲ್ಲಿ ರಚಿಸುವುದರಿಂದ ನಂತರದಲ್ಲಿ ಅದನ್ನು ಮತ್ತೆ ಬಳಸುವುದು ಸುಲಭವಾಗುತ್ತದೆ. getLocales ಕೆಲವು ಅಂತರಗತ ದೋಷ ನಿರ್ವಹಣೆಯೊಂದಿಗೆ ಕೇವಲ ಒಂದು ಸಹಾಯಕ ಕಾರ್ಯವಾಗಿದೆ. ಈಗ, /app/[locale]/tacotranslate.tsx ಎಂಬ ಹೆಸರಿನ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ, ಅಲ್ಲಿ ನಾವು TacoTranslate ಪ್ರೊವೈಡರ್ ಅನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವೆವು.

/app/[locale]/tacotranslate.tsx

'use client';

import React, {type ReactNode} from 'react';
import {
	type TranslationContextProperties,
	TacoTranslate as ImportedTacoTranslate,
} from 'tacotranslate/react';
import tacoTranslateClient from '@/tacotranslate-client';

export default function TacoTranslate({
	locale,
	origin,
	localizations,
	children,
}: TranslationContextProperties & {
	readonly children: ReactNode;
}) {
	return (
		<ImportedTacoTranslate
			client={tacoTranslateClient}
			locale={locale}
			origin={origin}
			localizations={localizations}
		>
			{children}
		</ImportedTacoTranslate>
	);
}

ಇದವು ಗ್ರಾಹಕ ಕಂಪೋನೆಂಟ್ ಎಂದು ಸೂಚಿಸುವ 'use client'; ಗಮನಿಸಿ.

ಸಂದರ್ಭದ ಪ್ರೊವೈಡರ್ ಈಗ ಸಿದ್ಧವಾಗಿರುವುದರಿಂದ, ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ರೂಟ್ ಲೇಔಟ್ ಆಗಿರುವ /app/[locale]/layout.tsx ಎಂಬ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ. ಈ ಪಥದಲ್ಲಿ Dynamic Routes ಬಳಕೆಯಲ್ಲಿರುವ ಫೋಲ್ಡರ್ ಇದೆ, ಅಲ್ಲಿ [locale] ಡೈನಾಮಿಕ್ ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿದೆ.

/app/[locale]/layout.tsx

import React, {type ReactNode} from 'react';
import {type Locale, isRightToLeftLocaleCode} from 'tacotranslate';
import './global.css';
import tacoTranslateClient from '@/tacotranslate-client';
import TacoTranslate from './tacotranslate';

export async function generateStaticParams() {
	const locales = await tacoTranslateClient.getLocales();
	return locales.map((locale) => ({locale}));
}

type RootLayoutParameters = {
	readonly params: Promise<{locale: Locale}>;
	readonly children: ReactNode;
};

export default async function RootLayout({params, children}: RootLayoutParameters) {
	const {locale} = await params;
	const origin = process.env.TACOTRANSLATE_ORIGIN;
	const localizations = await tacoTranslateClient.getLocalizations({
		locale,
		origins: [origin /* , other origins to fetch */],
	});

	return (
		<html lang={locale} dir={isRightToLeftLocaleCode(locale) ? 'rtl' : 'ltr'}>
			<body>
				<TacoTranslate
					locale={locale}
					origin={origin}
					localizations={localizations}
				>
					{children}
				</TacoTranslate>
			</body>
		</html>
	);
}

ಇಲ್ಲಿ ಮೊದಲನೆಯದಾಗಿ ಗಮನಿಸಬೇಕಾದ ವಿಷಯ ಅದು ನಾವು ನಮ್ಮ Dynamic Route ಪರಿಮಾಣ [locale] ಅನ್ನು ಆ ಭಾಷೆಯ ಅನುವಾದಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳಲು ಬಳಸುತ್ತಿದ್ದೇವೆ ಎಂಬುದು. ಜೊತೆಗೆ, generateStaticParams ನಿಮ್ಮ ಯೋಜನೆಗಾಗಿ ಸಕ್ರಿಯಗೊಳಿಸಿದ ಎಲ್ಲಾ ಸ್ಥಳೀಯ ಕೋಡ್‌ಗಳು ಮುಂಚಿತವಾಗಿ ರೆಂಡರ್ ಆಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತಿದೆ.

ಈಗ, ನಮ್ಮ ಮೊದಲ ಪುಟವನ್ನು ನಿರ್ಮಿಸಿ! /app/[locale]/page.tsx ಎಂದು ಹೆಸರಿಸಲಾದ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ.

/app/[locale]/page.tsx

import React from 'react';
import {Translate} from 'tacotranslate/react';

export const revalidate = 60;
export default async function Page() {
	return (
		<Translate string="Hello, world!" />
	);
}

Next.js ಗೆ ಪುಟವನ್ನು 60 ಸೆಕೆಂಡುಗಳ ನಂತರ ಮತ್ತೆ ನಿರ್ಮಿಸುವಂತೆ ಮತ್ತು ನಿಮ್ಮ ಅನುವಾದಗಳನ್ನು حديث保持ಲು ಸೂಚಿಸುವ revalidate ಪರಿವರ್ತಿಯನ್ನು ಗಮನಿಸಿ.

ಹಂತ 4: ಸರ್ವರ್ ಸೈಡ್ ರೆಂಡರಿಂಗ್ ಅನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವುದು

TacoTranslate ಸರ್ವರ್ ಸೈಡ್ ರೆಂಡರಿಂಗ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಇದರಿಂದ ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಬಹುಮಟ್ಟಿಗೆ ಸುಧಾರಿಸುತ್ತದೆ ಏಕೆಂದರೆ ತಕ್ಷಣವೇ ಅನುವಾದಿತ ವಿಷಯವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ, ಮೊದಲಾಗಿ ಅನುವಾದಿಸದ ವಿಷಯದ ಫ್ಲಾಶ್ ಅನ್ನು ತೋರಿಸುವ ಬದಲು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಾವು ಕ್ಲೈಂಟ್ನಲ್ಲಿ ನೆಟ್ವರ್ಕ್ ವಿನಂತಿಗಳನ್ನು ತಪ್ಪಿಸಬಹುದು, ಏಕೆಂದರೆ ಬಳಕೆದಾರ ವೀಕ್ಷಿಸುತ್ತಿರುವ ಪುಟಕ್ಕೆ ಅಗತ್ಯವಿರುವ ಅನುವಾದಗಳು ನಮಗಿದ್ದುದೇ ಇದೆ.

ಸರ್ವರ್ ಸೈಡ್ ರೆಂಡರಿಂಗ್ সেটಪ್ ಮಾಡಲು, /next.config.js ಅನ್ನು ರಚಿಸಿ ಅಥವಾ ಬದಲಾಯಿಸಿ:

/next.config.js

const withTacoTranslate = require('tacotranslate/next/config').default;
const tacoTranslateClient = require('./tacotranslate-client');

module.exports = async () => {
	const config = await withTacoTranslate(
		{},
		{
			client: tacoTranslateClient,
			isProduction:
				process.env.TACOTRANSLATE_ENV === 'production' ||
				process.env.VERCEL_ENV === 'production' ||
				(!(process.env.TACOTRANSLATE_ENV || process.env.VERCEL_ENV) &&
					process.env.NODE_ENV === 'production'),
		}
	);

	// NOTE: Remove i18n from config when using the app router
	return {...config, i18n: undefined};
};

ನಿಮ್ಮ ಸೆಟ್ಟಪ್‌ಗೆ ಅನುಗುಣವಾಗಿ isProduction ಪರಿಶೀಲನೆವನ್ನು ಬದಲಾಯಿಸಿ. true ಇದ್ದರೆ, TacoTranslate ಸಾರ್ವಜನಿಕ API ಕೀನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ನಾವು ಸ್ಥಳೀಯ, ಪರೀಕ್ಷಾ, ಅಥವಾ ಸ್ಟೇಜಿಂಗ್ ಪರಿಸರದಲ್ಲಿದ್ದರೆ (isProduction is false), ಹೊಸ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಅನುವಾದಕ್ಕೆ ಕಳುಹಿಸುವುದಕ್ಕಾಗಿ ರಹಸ್ಯ read/write API ಕೀ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.

ನಿರೀಕ್ಷಿತ ರೀತಿಯಲ್ಲಿ ಮಾರ್ಗಸೂಚಿ ಮತ್ತು ಮರುನಿರ್ದೇಶನ ಕಾರ್ಯನಿರ್ವಹಿಸಲು, ನಾವು /middleware.ts ಎಂಬ ಫೈಲ್ನ್ನು ರಚಿಸಬೇಕಾಗುತ್ತದೆ. Middleware ಬಳಸಿಕೊಂಡು, ನಾವು ಬಳಕೆದಾರರನ್ನು ಅವರ ಇಚ್ಛಿತ ಭಾಷೆಯಲ್ಲಿ ನೀಡಲಾದ ಪುಟಗಳಿಗೆ ಮರುನಿರ್ದೇಶಿಸಬಹುದು.

/middleware.ts

import {type NextRequest} from 'next/server';
import {middleware as tacoTranslateMiddleware} from 'tacotranslate/next';
import tacoTranslate from '@/tacotranslate-client';

export const config = {
	matcher: ['/((?!api|_next|favicon.ico).*)'],
};

export async function middleware(request: NextRequest) {
	return tacoTranslateMiddleware(tacoTranslate, request);
}

matcher ಅನ್ನು Next.js Middleware ಡಾಕ್ಯುಮೆಂಟೇಶನ್ ನ ಅನುಸಾರವಾಗಿ ترتيب ಮಾಡಿಕೊಳ್ಳಲು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಗ್ರಾಹಕ passagemನಲ್ಲಿ, ಬಳಕೆದಾರ್ ಪ್ರಿಯತಮ ಭಾಷೆಯನ್ನು ಬದಲಾವಣೆ ಮಾಡಲು locale ಕೂಕಿ ಅನ್ನು ಬದಲಾಯಿಸಬಹುದು. ದಯವಿಟ್ಟು ಈ ಮಾಡುವುದು ಹೇಗೆ ಎಂಬುದರ ಬಗ್ಗೆ ಪೂರ್ಣ ಉದಾಹರಣೆ ಕೋಡ್ ಅನ್ನು ನೋಡಿ!

ಹಂತ 5: ಡಿಪ್ಲಾಯ್ ಮಾಡಿ ಮತ್ತು ಪರೀಕ್ಷಿಸಿ!

ನಾವು ಮುಗಿಸಿದೆವು! ನೀವು ಯಾವುದೇ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು Translate ಕಂಪೋONENT್‌ಗೆ ಸೇರಿಸುವಾಗ ನಿಮ್ಮ React ಅಪ್ಲಿಕೇಶನ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅನುವಾದವಾಗುತ್ತದೆ. API ಕೀ ಮೇಲೆ read/write ಅನುಮತಿಗಳಿರುವ ಪರಿಸರಗಳಲ್ಲಿ ಮಾತ್ರ ಹೊಸ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಅನುವಾದಕ್ಕಾಗಿ ರಚಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ನಾವು, ನಿಮ್ಮ ಉತ್ಪಾದನಾ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಇದೇ ರೀತಿಯ API ಕೀ ಜೊತೆ ಪರೀಕ್ಷಿಸಲು ನೀವು ಮುಚ್ಚಲಾದ ಮತ್ತು ಸುರಕ್ಷಿತವಾದ ಸ್ಟೇಜಿಂಗ್ ಪರಿಸರವನ್ನು ಹೊಂದಿರುವುದು ಸೂಕ್ತವೆಂದು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ, ಲೈವ್ ಆಗಲು ಮೊದಲು ಹೊಸ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಸೇರಿಸುವುದಕ್ಕಾಗಿ. ಇದು ಯಾರಿಗೂ ನಿಮ್ಮ ರಹಸ್ಯ API ಕೀ ಕದಿಸಿಕೊಳ್ಳುವುದನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ಹೊಸ, ಸಂಬಂಧಮಾನವಲ್ಲದ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ನಿಮ್ಮ ಅನುವಾದ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಅಗತ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿ ಭರ್ತಿಮಾಡುವುದನ್ನು ತಡೆಯುತ್ತದೆ.