Datasets:

Devendra174
/

react-code-dataset

Dataset card Files Files and versions

react-code-dataset / wp-calypso /client /lib /i18n-utils /switch-locale.js

Devendra174's picture

Upload folder using huggingface_hub

1e92f2d verified 8 months ago

history blame contribute delete

20.4 kB

	import config from '@automattic/calypso-config';
	import { captureException } from '@automattic/calypso-sentry';
	import { getUrlFromParts, getUrlParts } from '@automattic/calypso-url';
	import { isDefaultLocale, getLanguage } from '@automattic/i18n-utils';
	import { setLocale as setLocaleNumberFormatters } from '@automattic/number-formatters';
	import debugFactory from 'debug';
	import i18n from 'i18n-calypso';
	import { forEach, throttle } from 'lodash';
	const debug = debugFactory( 'calypso:i18n' );

	const getPromises = {};

	/**
	* De-duplicates repeated GET fetches of the same URL while one is taking place.
	* Once it's finished, it'll allow for the same request to be done again.
	* @param {string} url The URL to fetch
	* @returns {Promise} The fetch promise.
	*/
	function dedupedGet( url ) {
	if ( ! ( url in getPromises ) ) {
	getPromises[ url ] = globalThis.fetch( url ).finally( () => delete getPromises[ url ] );
	}

	return getPromises[ url ];
	}

	/**
	* Get the protocol, domain, and path part of the language file URL.
	* Normally it should only serve as a helper function for `getLanguageFileUrl`,
	* but we export it here still in help with the test suite.
	* @returns {string} The path URL to the language files.
	*/
	export function getLanguageFilePathUrl() {
	const protocol = typeof window === 'undefined' ? 'https://' : '//'; // use a protocol-relative path in the browser

	return `${ protocol }widgets.wp.com/languages/calypso/`;
	}

	/**
	* Get the base path for language related files that are served from within Calypso.
	* @returns {string} The internal base file path for language files.
	*/
	export function getLanguagesInternalBasePath() {
	return `/calypso/languages`;
	}

	/**
	* Get the language file URL for the given locale and file type, js or json.
	* A revision cache buster will be appended automatically if `setLangRevisions` has been called beforehand.
	* @param {string} localeSlug A locale slug. e.g. fr, jp, zh-tw
	* @param {string} fileType The desired file type, js or json. Default to json.
	* @param {Object} languageRevisions An optional language revisions map. If it exists, the function will append the revision within as cache buster.
	* @returns {string} A language file URL.
	*/
	export function getLanguageFileUrl( localeSlug, fileType = 'json', languageRevisions = {} ) {
	if ( ! [ 'js', 'json' ].includes( fileType ) ) {
	fileType = 'json';
	}

	const fileUrl = `${ getLanguageFilePathUrl() }${ localeSlug }-v1.1.${ fileType }`;
	let revision = languageRevisions[ localeSlug ];

	if ( typeof revision === 'number' ) {
	revision = revision.toString();
	}

	return typeof revision === 'string' ? fileUrl + `?v=${ revision }` : fileUrl;
	}

	function getHtmlLangAttribute() {
	// translation of this string contains the desired HTML attribute value
	const slug = i18n.translate( 'html_lang_attribute' );

	// Hasn't been translated? Some languages don't have the translation for this string,
	// or maybe we are dealing with the default `en` locale. Return the general purpose locale slug
	// -- there's no special one available for `<html lang>`.
	if ( slug === 'html_lang_attribute' ) {
	return i18n.getLocaleSlug();
	}

	return slug;
	}

	function setLocaleInDOM() {
	const htmlLangAttribute = getHtmlLangAttribute();
	const isRTL = i18n.isRtl();
	document.documentElement.lang = htmlLangAttribute;
	document.documentElement.dir = isRTL ? 'rtl' : 'ltr';
	document.body.classList[ isRTL ? 'add' : 'remove' ]( 'rtl' );

	switchWebpackCSS( isRTL );
	}

	export async function getFile( url ) {
	const response = await dedupedGet( url );
	if ( response.ok ) {
	if ( response.bodyUsed ) {
	// If the body was already used, we assume that we already parsed the
	// response and set the locale in the DOM, so we don't need to do anything
	// else here.
	return;
	}
	return await response.json();
	}

	// Invalid response.
	throw new Error();
	}

	export function getLanguageFile( targetLocaleSlug ) {
	const languageRevisions = typeof window !== 'undefined' ? window.languageRevisions : {};
	const url = getLanguageFileUrl( targetLocaleSlug, 'json', languageRevisions );

	return getFile( url );
	}

	/**
	* Get the language manifest file URL for the given locale.
	* A revision cache buster will be appended automatically if `setLangRevisions` has been called beforehand.
	* @param {string} options Funciton options object
	* @param {string} options.localeSlug A locale slug. e.g. fr, jp, zh-tw
	* @param {string} options.fileType The desired file type, js or json. Default to json.
	* @param {string} options.hash Build hash string that will be used as cache buster.
	* @returns {string} A language manifest file URL.
	*/

	export function getLanguageManifestFileUrl( { localeSlug, fileType = 'json', hash = null } = {} ) {
	if ( ! [ 'js', 'json' ].includes( fileType ) ) {
	fileType = 'json';
	}

	if ( typeof hash === 'number' ) {
	hash = hash.toString();
	}

	const fileBasePath = getLanguagesInternalBasePath();
	const fileUrl = `${ fileBasePath }/${ localeSlug }-language-manifest.${ fileType }`;

	return typeof hash === 'string' ? fileUrl + `?v=${ hash }` : fileUrl;
	}

	/**
	* Whether the language manifest is preloaded, i.e. localeSlug is matched in window.i18nLanguageManifest.
	* @param {string} localeSlug A locale slug. e.g. fr, jp, zh-tw
	* @returns {boolean} Whether the language manifest is preloaded
	*/
	function getIsLanguageManifestPreloaded( localeSlug ) {
	return (
	window?.i18nLanguageManifest &&
	window?.i18nLanguageManifest?.locale?.[ '' ]?.localeSlug === localeSlug
	);
	}

	/**
	* Get the language manifest file for the given locale.
	* @param {string} localeSlug A locale slug. e.g. fr, jp, zh-tw
	* @returns {Object \| Promise} Language manifest json content
	*/
	export function getLanguageManifestFile( localeSlug ) {
	if ( getIsLanguageManifestPreloaded( localeSlug ) ) {
	return window.i18nLanguageManifest;
	}

	const url = getLanguageManifestFileUrl( {
	localeSlug,
	fileType: 'json',
	hash: window?.languageRevisions?.hashes?.[ localeSlug ] \|\| null,
	} );

	return getFile( url );
	}

	/**
	* Get the translation chunk file URL for the given chunk id and locale.
	* A revision cache buster will be appended automatically if `setLangRevisions` has been called beforehand.
	* @param {string} options Funciton options object
	* @param {string} options.chunkId A chunk id. e.g. chunk-abc.min
	* @param {string} options.localeSlug A locale slug. e.g. fr, jp, zh-tw
	* @param {string} options.fileType The desired file type, js or json. Default to json.
	* @param {string} options.hash Build hash string that will be used as cache buster.
	* @returns {string} A translation chunk file URL.
	*/
	export function getTranslationChunkFileUrl( {
	chunkId,
	localeSlug,
	fileType = 'json',
	hash = null,
	} = {} ) {
	if ( ! [ 'js', 'json' ].includes( fileType ) ) {
	fileType = 'json';
	}

	if ( typeof hash === 'number' ) {
	hash = hash.toString();
	}

	const fileBasePath = getLanguagesInternalBasePath();
	const fileName = `${ localeSlug }-${ chunkId }.${ fileType }`;
	const fileUrl = `${ fileBasePath }/${ fileName }`;

	return typeof hash === 'string' ? fileUrl + `?v=${ hash }` : fileUrl;
	}

	/**
	* Whether the translation chunk is preloaded, i.e. exists in window.i18nTranslationChunks.
	* @param {string} chunkId chunkId A chunk id. e.g. chunk-abc.min
	* @param {string} localeSlug A locale slug. e.g. fr, jp, zh-tw
	* @returns {boolean} Whether the chunk translations are preloaded
	*/
	function getIsTranslationChunkPreloaded( chunkId, localeSlug ) {
	if ( typeof window !== 'undefined' ) {
	return (
	window.i18nLanguageManifest?.locale?.[ '' ]?.localeSlug === localeSlug &&
	window.i18nTranslationChunks &&
	chunkId in window.i18nTranslationChunks
	);
	}
	return false;
	}

	/**
	* Get the translation chunk file for the given chunk id and locale.
	* @param {string} chunkId A chunk id. e.g. chunk-abc.min
	* @param {string} localeSlug A locale slug. e.g. fr, jp, zh-tw
	* @returns {Promise} Translation chunk json content
	*/
	export function getTranslationChunkFile( chunkId, localeSlug ) {
	if ( getIsTranslationChunkPreloaded( chunkId, localeSlug ) ) {
	return Promise.resolve( window.i18nTranslationChunks[ chunkId ] );
	}

	const url = getTranslationChunkFileUrl( {
	chunkId,
	localeSlug,
	fileType: 'json',
	hash: window?.languageRevisions?.[ localeSlug ] \|\| null,
	} );

	return getFile( url );
	}

	/**
	* Get the ids of all loaded chunks via either script tag on the page
	* or loaded asynchronously with dynamic imports.
	* @returns {Array} Chunk ids
	*/
	function getInstalledChunks() {
	const installedChunksFromContext = window.installedChunks ?? [];
	const installedChunksAsync = window?.__requireChunkCallback__?.getInstalledChunks?.() ?? [];
	const installedChunksSet = new Set(
	[].concat( installedChunksFromContext, installedChunksAsync )
	);

	return Array.from( installedChunksSet );
	}

	/**
	* Capture exceptions from `getTranslationChunkFile`.
	* @param {Error} error
	* @param {string} chunkId
	* @param {string} localeSlug
	*/
	// eslint-disable-next-line no-unused-vars
	function captureGetTranslationChunkFileException( error, chunkId, localeSlug ) {
	captureException( error, {
	tags: {
	chunk_id: chunkId,
	locale_slug: localeSlug,
	},
	} );
	}

	/**
	* Used to keep the reference to the require chunk translations handler.
	*/
	let lastRequireChunkTranslationsHandler = null;

	/**
	* Adds require chunk handler for fetching translations.
	* @param {string} localeSlug A locale slug. e.g. fr, jp, zh-tw
	* @param {Object} options Handler additional options
	* @param {Array} options.translatedChunks Array of chunk ids that have available translation for the given locale
	* @param {Object} options.userTranslations User translations data that will override chunk translations
	*/
	function addRequireChunkTranslationsHandler( localeSlug = i18n.getLocaleSlug(), options = {} ) {
	const { translatedChunks = [], userTranslations = {} } = options;
	const loadedTranslationChunks = {};

	const handler = ( { scriptSrc, publicPath }, promises ) => {
	const chunkId = scriptSrc.replace( publicPath, '' ).replace( /\.js$/, '' );

	if ( ! translatedChunks.includes( chunkId ) \|\| loadedTranslationChunks[ chunkId ] ) {
	return;
	}

	const translationChunkPromise = getTranslationChunkFile( chunkId, localeSlug )
	.then( ( translations ) => {
	addTranslations( translations, userTranslations );
	loadedTranslationChunks[ chunkId ] = true;
	} )
	.catch( ( cause ) => {
	const error = new Error(
	`Encountered an error loading translation chunk in require chunk translations handler.`,
	{ cause }
	);
	// @todo: Enable again when figure out how to prevent the spam caused by these errors.
	// captureGetTranslationChunkFileException( error, chunkId, localeSlug );
	debug( error );
	} );

	promises.push( translationChunkPromise );
	};

	window?.__requireChunkCallback__?.add?.( handler );
	lastRequireChunkTranslationsHandler = handler;
	}

	/**
	* Removes require chunk translations handler.
	*/
	function removeRequireChunkTranslationsHandler() {
	window?.__requireChunkCallback__?.remove?.( lastRequireChunkTranslationsHandler );
	}

	let lastRequestedLocale = null;
	export default async function switchLocale( localeSlug ) {
	// check if the language exists in config.languages
	const language = getLanguage( localeSlug );

	if ( ! language ) {
	return;
	}

	// Note: i18n is a singleton that will be shared between all server requests!
	// Disable switching locale on the server
	if ( typeof document === 'undefined' ) {
	return;
	}

	// Propagate the locale to @automattic/number-formatters
	setLocaleNumberFormatters( localeSlug );

	lastRequestedLocale = localeSlug;

	const useTranslationChunks =
	config.isEnabled( 'use-translation-chunks' ) \|\|
	getUrlParts( document.location.href ).searchParams.has( 'useTranslationChunks' );

	if ( isDefaultLocale( localeSlug ) ) {
	i18n.configure( { defaultLocaleSlug: localeSlug } );
	setLocaleInDOM();
	} else if ( useTranslationChunks ) {
	// If requested locale is same as current locale, we don't need to
	// re-fetch the manifest and translation chunks.
	if ( localeSlug === i18n.getLocaleSlug() ) {
	setLocaleInDOM();
	return;
	}

	// Switching the locale requires fetching the translation chunks
	// locale data, which consists of the locale manifest data and
	// translations for currently installed chunks.
	try {
	const languageManifest = getLanguageManifestFile( localeSlug );
	const { translatedChunks, locale } =
	( languageManifest instanceof Promise ? await languageManifest : languageManifest ) ?? {}; // Using await operator on non-Promise object would still split the execution flow which causes unnecessary delay.

	if ( ! locale \|\| ! translatedChunks ) {
	return;
	}

	i18n.setLocale( locale );
	setLocaleInDOM();
	removeRequireChunkTranslationsHandler();
	addRequireChunkTranslationsHandler( localeSlug, { translatedChunks } );

	const translatedInstalledChunks = getInstalledChunks().filter( ( chunkId ) =>
	translatedChunks.includes( chunkId )
	);
	const preloadedTranslatedInstalledChunks = translatedInstalledChunks.filter( ( chunkId ) =>
	getIsTranslationChunkPreloaded( chunkId, localeSlug )
	);
	const translatedInstalledChunksToBeLoaded = translatedInstalledChunks.filter(
	( chunkId ) => ! getIsTranslationChunkPreloaded( chunkId, localeSlug )
	);

	// Add preloaded translation chunks
	const preloadedTranslations = preloadedTranslatedInstalledChunks.reduce(
	( acc, chunkId ) => Object.assign( acc, window.i18nTranslationChunks?.[ chunkId ] ),
	{}
	);
	addTranslations( preloadedTranslations );

	// Load individual translation chunks
	translatedInstalledChunksToBeLoaded.forEach( ( chunkId ) =>
	getTranslationChunkFile( chunkId, localeSlug )
	.then( ( translations ) => addTranslations( translations ) )
	.catch( ( cause ) => {
	const error = new Error(
	`Encountered an error loading translation chunk while switching the locale.`,
	{ cause }
	);
	// @todo: Enable again when figure out how to prevent the spam caused by these errors.
	// captureGetTranslationChunkFileException( error, chunkId, localeSlug );
	debug( error );
	} )
	);

	const userTranslations = await loadUserUndeployedTranslations( localeSlug );

	// Re-attach require chunk translations handler if user translations are available
	if ( userTranslations ) {
	removeRequireChunkTranslationsHandler();
	addRequireChunkTranslationsHandler( localeSlug, {
	translatedChunks,
	userTranslations,
	} );
	}
	} catch ( error ) {
	debug(
	`Encountered an error loading language manifest and/or translation chunks for ${ localeSlug }. Falling back to English.`
	);
	debug( error );
	}
	} else {
	getLanguageFile( localeSlug ).then(
	// Success.
	( body ) => {
	if ( body ) {
	// Handle race condition when we're requested to switch to a different
	// locale while we're in the middle of request, we should abandon result
	if ( localeSlug !== lastRequestedLocale ) {
	return;
	}

	i18n.setLocale( body );
	setLocaleInDOM();
	loadUserUndeployedTranslations( localeSlug );
	}
	},
	// Failure.
	() => {
	debug(
	`Encountered an error loading locale file for ${ localeSlug }. Falling back to English.`
	);
	}
	);
	}
	}

	export function loadUserUndeployedTranslations( currentLocaleSlug ) {
	if ( typeof window === 'undefined' \|\| ! window.location \|\| ! window.location.search ) {
	return;
	}

	const search = new URLSearchParams( window.location.search );
	const params = Object.fromEntries( search.entries() );

	const {
	'load-user-translations': username,
	project = 'wpcom',
	translationSet = 'default',
	translationStatus = 'current',
	locale = currentLocaleSlug,
	} = params;

	if ( ! username ) {
	return;
	}

	if ( ! [ 'current', 'waiting' ].includes( translationStatus ) ) {
	return;
	}

	if ( 'waiting' === translationStatus ) {
	// TODO only allow loading your own waiting translations. Disallow loading them for now.
	return;
	}

	const pathname = [
	'api',
	'projects',
	project,
	locale,
	translationSet,
	'export-translations',
	].join( '/' );

	const searchParams = new URLSearchParams( {
	'filters[user_login]': username,
	'filters[status]': translationStatus,
	format: 'json',
	} );

	const requestUrl = getUrlFromParts( {
	protocol: 'https:',
	host: 'translate.wordpress.com',
	pathname,
	searchParams,
	} );

	return window
	.fetch( requestUrl.href, {
	headers: { Accept: 'application/json' },
	credentials: 'include',
	} )
	.then( ( res ) => res.json() )
	.then( ( translations ) => {
	addTranslations( translations );

	return translations;
	} );
	}

	/*
	* CSS links come in two flavors: either RTL stylesheets with `.rtl.css` suffix, or LTR ones
	* with `.css` suffix. This function sets a desired `isRTL` flag on the supplied URL, i.e., it
	* changes the extension if necessary.
	*/
	function setRTLFlagOnCSSLink( url, isRTL ) {
	if ( isRTL ) {
	return url.endsWith( '.rtl.css' ) ? url : url.replace( /\.css$/, '.rtl.css' );
	}

	return ! url.endsWith( '.rtl.css' ) ? url : url.replace( /\.rtl.css$/, '.css' );
	}

	/**
	* Switch the Calypso CSS between RTL and LTR versions.
	* @param {boolean} isRTL True to use RTL css.
	*/
	export function switchWebpackCSS( isRTL ) {
	const currentLinks = document.querySelectorAll( 'link[rel="stylesheet"][data-webpack]' );

	forEach( currentLinks, async ( currentLink ) => {
	const currentHref = currentLink.getAttribute( 'href' );
	const newHref = setRTLFlagOnCSSLink( currentHref, isRTL );
	const isNewHrefAdded = currentLink.parentElement?.querySelector( `[href = '${ newHref }']` );

	if ( currentHref === newHref \|\| isNewHrefAdded ) {
	return;
	}

	const newLink = await loadCSS( newHref, currentLink );

	if ( newLink ) {
	newLink.setAttribute( 'data-webpack', true );
	currentLink.parentElement?.removeChild( currentLink );
	}
	} );
	}

	/**
	* Loads a CSS stylesheet into the page.
	* @param {string} cssUrl URL of a CSS stylesheet to be loaded into the page
	* @param {window.Element} currentLink an existing <link> DOM element before which we want to insert the new one
	* @returns {Promise<string>} the new <link> DOM element after the CSS has been loaded
	*/
	function loadCSS( cssUrl, currentLink ) {
	return new Promise( ( resolve ) => {
	// While looping the current links the RTL state might have changed
	// This is a double-check to ensure the value of isRTL
	const isRTL = i18n.isRtl();
	const isRTLHref = currentLink.getAttribute( 'href' ).endsWith( '.rtl.css' );

	if ( isRTL === isRTLHref ) {
	return resolve( null );
	}

	const link = document.createElement( 'link' );
	link.rel = 'stylesheet';
	link.type = 'text/css';
	link.href = cssUrl;

	if ( 'onload' in link ) {
	link.onload = () => {
	link.onload = null;
	resolve( link );
	};
	} else {
	// just wait 500ms if the browser doesn't support link.onload
	// https://pie.gd/test/script-link-events/
	// https://github.com/ariya/phantomjs/issues/12332
	setTimeout( () => resolve( link ), 500 );
	}

	document.head.insertBefore( link, currentLink ? currentLink.nextSibling : null );
	} );
	}

	/**
	* Translation data batch strore.
	* @type {Array}
	*/
	const _translationsBatch = [];

	/**
	* A throttle wrapper around i18n.addTranslations.
	*
	* This function also saves the duration of the call as a performance measure
	* @param {Object} userTranslations User translations data that will override chunk translations
	*/
	const _addTranslationsBatch = throttle( function ( userTranslations ) {
	window.performance?.mark?.( 'add_translations_start' );
	i18n.addTranslations( Object.assign( {}, ..._translationsBatch.splice( 0 ), userTranslations ) );
	window.performance?.measure?.( 'add_translations', 'add_translations_start' );
	window.performance?.clearMarks?.( 'add_translations_start' );
	}, 50 );

	/**
	* Adds new translations to the existing locale data.
	* @param {Object} translations Translations data
	* @param {Object} [userTranslations] User translations data that will override chunk translations
	*/
	function addTranslations( translations, userTranslations ) {
	_translationsBatch.push( translations );
	_addTranslationsBatch( userTranslations );
	}