@prezly/theme-kit-nextjs 2.0.1-1 → 2.1.0

package/src/intl/languages.ts

@@ -0,0 +1,233 @@
+import type { CultureRef, NewsroomLanguageSettings, Story } from '@prezly/sdk';
+
+import { DUMMY_DEFAULT_LOCALE } from './locale';
+import { LocaleObject } from './localeObject';
+
+function isOnlyCulture(culture: CultureRef, languages: NewsroomLanguageSettings[]): boolean {
+    const numberOfLanguages = languages.filter(
+        ({ locale: { language_code } }) => language_code === culture.language_code,
+    ).length;
+
+    return numberOfLanguages === 1;
+}
+
+/**
+ * @returns the display name of the locale in its native language
+ *
+ * If there's only one culture used in a specific language,
+ * we strip the culture name completely.
+ *
+ * Examples:
+ *  - English (Global), Spanish (Spain)
+ *  - -> English, Spanish
+ *  - English (Global), English (UK), Spanish (Spain)
+ *  - -> English (Global), English (UK), Spanish
+ */
+export function getLanguageDisplayName(
+    language: NewsroomLanguageSettings,
+    languages: NewsroomLanguageSettings[],
+): string {
+    const { locale } = language;
+
+    if (isOnlyCulture(locale, languages)) {
+        const cultureNameIndex = locale.native_name.indexOf('(');
+
+        if (cultureNameIndex !== -1) {
+            return locale.native_name.slice(0, cultureNameIndex - 1);
+        }
+    }
+
+    return locale.native_name;
+}
+
+/**
+ * @returns Language set as default in the Newsroom Settings.
+ */
+export function getDefaultLanguage(languages: NewsroomLanguageSettings[]) {
+    return languages.find(({ is_default }) => is_default) || languages[0];
+}
+
+/**
+ * @returns Only languages having at least one published story
+ */
+export function getUsedLanguages(languages: NewsroomLanguageSettings[]) {
+    return languages.filter((language) => language.public_stories_count > 0);
+}
+
+export function getLanguageByExactLocaleCode(
+    languages: NewsroomLanguageSettings[],
+    locale: LocaleObject,
+) {
+    const localeCode = locale.toUnderscoreCode();
+    return languages.find(({ code }) => code === localeCode);
+}
+
+// See https://github.com/prezly/prezly/blob/master/lib/model/CulturePeer.php#L123
+export function getLanguageByNeutralLocaleCode(
+    languages: NewsroomLanguageSettings[],
+    locale: LocaleObject,
+) {
+    const neutralLanguageCode = locale.toNeutralLanguageCode();
+
+    // Prefer default language
+    const defaultLanguage = getDefaultLanguage(languages);
+    // TODO: This doesn't align with other methods logic
+    if (defaultLanguage.code === locale.toUnderscoreCode()) {
+        return defaultLanguage;
+    }
+
+    // Try to look in used cultures first (giving priority to used ones)
+    const usedLanguages = getUsedLanguages(languages);
+    const usedLanguage = usedLanguages.find(
+        ({ code }) =>
+            LocaleObject.fromAnyCode(code).toNeutralLanguageCode() === neutralLanguageCode,
+    );
+    if (usedLanguage) {
+        return usedLanguage;
+    }
+
+    // Search in all languages
+    return languages.find(
+        ({ code }) =>
+            LocaleObject.fromAnyCode(code).toNeutralLanguageCode() === neutralLanguageCode,
+    );
+}
+
+// See https://github.com/prezly/prezly/blob/master/lib/model/CulturePeer.php#L159
+export function getLanguageByShortRegionCode(
+    languages: NewsroomLanguageSettings[],
+    locale: LocaleObject,
+) {
+    const shortRegionCode = locale.toRegionCode();
+
+    // Prefer default language
+    const defaultLanguage = getDefaultLanguage(languages);
+    if (LocaleObject.fromAnyCode(defaultLanguage.code).toRegionCode() === shortRegionCode) {
+        return defaultLanguage;
+    }
+
+    // Try to look in used cultures first (giving priority to used ones)
+    const usedLanguages = getUsedLanguages(languages);
+    const usedLanguage = usedLanguages.find(
+        ({ code }) => LocaleObject.fromAnyCode(code).toRegionCode() === shortRegionCode,
+    );
+    if (usedLanguage) {
+        return usedLanguage;
+    }
+
+    // Search in all languages
+    return languages.find(
+        ({ code }) => LocaleObject.fromAnyCode(code).toRegionCode() === shortRegionCode,
+    );
+}
+
+/**
+ * Retrieve a culture with fallback to legacy codes support.
+ * Pulled from https://github.com/prezly/prezly/blob/de9900d9890a33502780494aa3fb85c9a732b3c3/lib/model/CulturePeer.php#L91-L114
+ */
+export function getLanguageFromNextLocaleIsoCode(
+    languages: NewsroomLanguageSettings[],
+    nextLocaleIsoCode?: string,
+): NewsroomLanguageSettings | undefined {
+    const defaultLanguage = getDefaultLanguage(languages);
+
+    if (!nextLocaleIsoCode || nextLocaleIsoCode === DUMMY_DEFAULT_LOCALE) {
+        return defaultLanguage;
+    }
+
+    const locale = LocaleObject.fromAnyCode(nextLocaleIsoCode);
+    let targetLanguage: NewsroomLanguageSettings | undefined;
+
+    if (nextLocaleIsoCode.length >= 2 && nextLocaleIsoCode.length <= 4) {
+        // The order of methods here is reversed from `getShortestLocaleCode`, so that the logic "unwraps" the possible variants with no collisions
+        targetLanguage =
+            getLanguageByExactLocaleCode(languages, locale) ||
+            getLanguageByShortRegionCode(languages, locale) ||
+            getLanguageByNeutralLocaleCode(languages, locale);
+    } else {
+        targetLanguage = getLanguageByExactLocaleCode(languages, locale);
+    }
+
+    return targetLanguage;
+}
+
+export function getLanguageFromStory(languages: NewsroomLanguageSettings[], story: Story) {
+    const { code: storyLocaleCode } = story.culture;
+
+    return languages.find(({ code }) => code === storyLocaleCode);
+}
+
+/**
+ * Extracts company information for the selected locale
+ */
+export function getCompanyInformation(languages: NewsroomLanguageSettings[], locale: LocaleObject) {
+    const currentLanguage =
+        getLanguageByExactLocaleCode(languages, locale) || getDefaultLanguage(languages);
+
+    return currentLanguage.company_information;
+}
+
+/**
+ * Get newsroom notifications for the selected locale
+ */
+export function getNotifications(languages: NewsroomLanguageSettings[], locale: LocaleObject) {
+    const currentLanguage =
+        getLanguageByExactLocaleCode(languages, locale) || getDefaultLanguage(languages);
+
+    return currentLanguage.notifications;
+}
+
+/**
+ * Get the shortest locale code possible from full locale code
+ * First: try shorting to neutral language code (there should be no locales with the same language code)
+ * Then: try shorting to region code (there should be no locales with the same region code)
+ * Finally: return the original locale code (shorting is not possible)
+ *
+ * @param locale A LocaleObject constructed from FULL locale code (taken straight from the selected language)
+ */
+export function getShortestLocaleCode(
+    languages: NewsroomLanguageSettings[],
+    locale: LocaleObject,
+): string | false {
+    const localeCode = locale.toUnderscoreCode();
+    const defaultLanguage = getDefaultLanguage(languages);
+    // If it's a default locale, return false (no locale needed in URL)
+    if (localeCode === defaultLanguage.code) {
+        return false;
+    }
+
+    // Try shorting to neutral language code
+    const neutralLanguageCode = locale.toNeutralLanguageCode();
+    const matchingLanguagesByNeutralCode = languages.filter(
+        ({ code }) =>
+            LocaleObject.fromAnyCode(code).toNeutralLanguageCode() === neutralLanguageCode ||
+            code === neutralLanguageCode,
+    );
+    if (matchingLanguagesByNeutralCode.length === 1) {
+        return neutralLanguageCode;
+    }
+
+    // Try shorting to region code
+    const shortRegionCode = locale.toRegionCode();
+    const matchingLanguagesByRegionCode = languages.filter(
+        ({ code }) => LocaleObject.fromAnyCode(code).toRegionCode() === shortRegionCode,
+    );
+    // Prevent collision with neutral language codes
+    const lowerCasedShortRegionCode = shortRegionCode.toLowerCase();
+    const mathchingNeutralLanguagesByRegionCode = languages.filter(
+        ({ code }) =>
+            LocaleObject.fromAnyCode(code).toNeutralLanguageCode() === lowerCasedShortRegionCode ||
+            code === lowerCasedShortRegionCode,
+    );
+    if (
+        matchingLanguagesByRegionCode.length === 1 &&
+        // If there are 2 or more matching neutral languages, it means that there are no languages that can be shortened to neutral code
+        mathchingNeutralLanguagesByRegionCode.length !== 1 &&
+        // We don't want just numbers in our region code
+        Number.isNaN(Number(shortRegionCode))
+    ) {
+        return shortRegionCode;
+    }
+
+    return localeCode;
+}

package/src/intl/locale.test.ts

@@ -0,0 +1,95 @@
+import { jest } from '@jest/globals';
+import {
+    DEFAULT_LOCALE,
+    DUMMY_DEFAULT_LOCALE,
+    getLocaleDirection,
+    getRedirectToCanonicalLocale,
+    getSupportedLocaleIsoCode,
+} from './locale';
+import { LocaleObject } from './localeObject';
+
+describe('getSupportedLocaleIsoCode', () => {
+    it('returns a code by exact match', () => {
+        expect(getSupportedLocaleIsoCode(LocaleObject.fromAnyCode('en'))).toBe('en');
+        expect(getSupportedLocaleIsoCode(LocaleObject.fromAnyCode('af'))).toBe('af');
+        expect(getSupportedLocaleIsoCode(LocaleObject.fromAnyCode('pt-BR'))).toBe('pt-BR');
+    });
+
+    it('returns a code by neutral language code match', () => {
+        expect(getSupportedLocaleIsoCode(LocaleObject.fromAnyCode('en-US'))).toBe('en');
+        expect(getSupportedLocaleIsoCode(LocaleObject.fromAnyCode('de-DE'))).toBe('de');
+        expect(getSupportedLocaleIsoCode(LocaleObject.fromAnyCode('uk-UA'))).toBe('uk');
+    });
+
+    it('returns custom mapped codes for Chinese locales', () => {
+        expect(getSupportedLocaleIsoCode(LocaleObject.fromAnyCode('zh-Hant'))).toBe('zh-TW');
+        expect(getSupportedLocaleIsoCode(LocaleObject.fromAnyCode('zh-HK'))).toBe('zh-CN');
+    });
+
+    it('returns default locale code for unsupported languages', () => {
+        const consoleSpy = jest.spyOn(console, 'warn');
+
+        // @ts-expect-error
+        expect(getSupportedLocaleIsoCode(new LocaleObject('aa'))).toBe(DEFAULT_LOCALE);
+        expect(consoleSpy).toHaveBeenCalledWith(
+            'Unsupported locale provided. Please use `LocaleObject.fromAnyCode` to ensure you are using a correct language code',
+        );
+    });
+});
+
+describe('getRedirectToCanonicalLocale', () => {
+    it('returns undefined when no locale or dummy locale is provided', () => {
+        expect(getRedirectToCanonicalLocale('en', undefined, '/')).toBe(undefined);
+        expect(getRedirectToCanonicalLocale('en', DUMMY_DEFAULT_LOCALE, '/')).toBe(undefined);
+    });
+
+    it('returns undefined when locale is already canonical', () => {
+        expect(getRedirectToCanonicalLocale('en', 'en', '/')).toBe(undefined);
+        expect(getRedirectToCanonicalLocale('nl_BE', 'nl-be', '/')).toBe(undefined);
+    });
+
+    it('returns a redirect object when requested locale is not canonical', () => {
+        expect(getRedirectToCanonicalLocale(false, 'en-us', '/test')).toEqual({
+            destination: '/test',
+            permanent: false,
+        });
+
+        expect(getRedirectToCanonicalLocale('en', 'en-us', '/test')).toEqual({
+            destination: '/en/test',
+            permanent: false,
+        });
+
+        expect(getRedirectToCanonicalLocale('en', 'en-us', 'test')).toEqual({
+            destination: '/en/test',
+            permanent: false,
+        });
+    });
+
+    it('preserves query parameters', () => {
+        expect(
+            getRedirectToCanonicalLocale('en', 'en-us', '/test', {
+                page: '1',
+                tags: ['story', 'media'],
+            }),
+        ).toEqual({
+            destination: '/en/test?page=1&tags=story&tags=media',
+            permanent: false,
+        });
+    });
+});
+
+describe('getLocaleDirection', () => {
+    it('returns `rtl` for right-to-left languages', () => {
+        const RTL_LANGUAGES = ['ar', 'ar-AE', 'ar-BH', 'ar-QA', 'ar-SA', 'he-IL', 'ur-PK'];
+        RTL_LANGUAGES.forEach((language) => {
+            expect(getLocaleDirection(LocaleObject.fromAnyCode(language))).toBe('rtl');
+        });
+    });
+
+    it('returns `ltr` for other languages', () => {
+        const LTR_LANGUAGES = ['en', 'en-US', 'fr-FR', 'fil', 'pt-BR', 'nl', 'nl-BE'];
+        LTR_LANGUAGES.forEach((language) => {
+            expect(getLocaleDirection(LocaleObject.fromAnyCode(language))).toBe('ltr');
+        });
+    });
+});

package/src/intl/locale.ts

@@ -0,0 +1,140 @@
+import type { Redirect } from 'next';
+import type { ParsedUrlQuery } from 'querystring';
+import { stringify } from 'querystring';
+
+import { LocaleObject } from './localeObject';
+
+export const DEFAULT_LOCALE = 'en';
+// We use pseudo locale used for localization testing, to reliably determine if we need to fallback to the default newsroom language
+export const DUMMY_DEFAULT_LOCALE = 'qps-ploc';
+
+/**
+ * This a list of locales that Prezly has translations for. Each code represents a language file in the `@prezly/themes-intl-messages` package.
+ * See https://github.com/prezly/themes-intl-messages for more info.
+ */
+const SUPPORTED_LOCALES = [
+    'af',
+    'ar',
+    'az',
+    'be',
+    'bg',
+    'cs',
+    'da',
+    'de',
+    'el',
+    'en',
+    'es',
+    'et',
+    'fi',
+    'fil',
+    'fr',
+    'ga',
+    'he',
+    'hi',
+    'hr',
+    'hu',
+    'id',
+    'it',
+    'ja',
+    'kk',
+    'ko',
+    'lt',
+    'lv',
+    'mt',
+    'nl',
+    'no',
+    'pl',
+    'pt-BR',
+    'pt',
+    'ro',
+    'ru',
+    'sk',
+    'sl',
+    'sv',
+    'sw',
+    'th',
+    'tr',
+    'uk',
+    'ur',
+    'uz',
+    'vi',
+    'zh-CN',
+    'zh-TW',
+];
+
+/**
+ * Use this function to determine which translations file you should load from `@prezly/themes-intl-mesages` package.
+ * See https://github.com/prezly/theme-nextjs-bea/blob/main/utils/lang.ts for a usage example.
+ */
+export function getSupportedLocaleIsoCode(locale: LocaleObject): string {
+    const localeIsoCode = locale.toHyphenCode();
+
+    const isSupportedLocale =
+        localeIsoCode.length >= 2 && SUPPORTED_LOCALES.includes(localeIsoCode);
+    if (isSupportedLocale) {
+        return localeIsoCode;
+    }
+
+    const language = locale.toNeutralLanguageCode();
+    const isSupportedLanguage = SUPPORTED_LOCALES.includes(language);
+    if (isSupportedLanguage) {
+        return language;
+    }
+
+    // Custom mapping for Chinese locales
+    if (localeIsoCode.toLowerCase() === 'zh-hant') {
+        return 'zh-TW';
+    }
+    if (localeIsoCode.toLowerCase() === 'zh-hk') {
+        return 'zh-CN';
+    }
+
+    // This code should never be reached, because locale code check is happening in `LocaleObject.fromAnyCode`
+    // eslint-disable-next-line no-console
+    console.warn(
+        'Unsupported locale provided. Please use `LocaleObject.fromAnyCode` to ensure you are using a correct language code',
+    );
+    return DEFAULT_LOCALE;
+}
+
+export function getRedirectToCanonicalLocale(
+    shortestLocaleCode: string | false,
+    nextLocaleIsoCode: string | undefined,
+    redirectPath: string,
+    query?: ParsedUrlQuery,
+): Redirect | undefined {
+    // No need to redirect if no particular locale was requested by the application
+    if (!nextLocaleIsoCode || nextLocaleIsoCode === DUMMY_DEFAULT_LOCALE) {
+        return undefined;
+    }
+
+    const shortestLocaleSlug = shortestLocaleCode
+        ? LocaleObject.fromAnyCode(shortestLocaleCode).toUrlSlug()
+        : shortestLocaleCode;
+
+    if (shortestLocaleSlug !== nextLocaleIsoCode) {
+        const prefixedPath =
+            redirectPath && !redirectPath.startsWith('/') ? `/${redirectPath}` : redirectPath;
+
+        const urlQuery = query ? `?${stringify(query)}` : '';
+
+        return {
+            destination: shortestLocaleSlug
+                ? `/${shortestLocaleSlug}${prefixedPath}${urlQuery}`
+                : `${prefixedPath}${urlQuery}`,
+            permanent: false,
+        };
+    }
+
+    return undefined;
+}
+
+export function getLocaleDirection(locale: LocaleObject): 'ltr' | 'rtl' {
+    const neutralLanguageCode = locale.toNeutralLanguageCode();
+
+    if (['ar', 'he', 'ur'].includes(neutralLanguageCode)) {
+        return 'rtl';
+    }
+
+    return 'ltr';
+}

package/src/intl/localeConfig.js

@@ -0,0 +1,23 @@
+/**
+ * This list is pulled from the main Prezly application. The underscores are replaced with dashes.
+ * Together with permutation performed lower in the code,
+ * the exported list represents all of the possible locale codes that Next.js theme application might accept.
+ */
+const supportedLocales = require('./localeList');
+
+const lowercaseLocales = supportedLocales.map((l) => l.toLowerCase());
+
+// Get all permutations for the shorter locale codes supported by Prezly (e.g. short region codes and neutral language codes)
+const lowercaseLocalPermutations = Array.from(
+    new Set([
+        ...lowercaseLocales,
+        ...lowercaseLocales.map((code) => code.split('-')[0]),
+        ...lowercaseLocales
+            .map((code) => code.split('-')[1])
+            .filter(Boolean)
+            // Remove number-only codes from possible permutations (like `419` for `es-419`)
+            .filter((code) => Number.isNaN(Number(code))),
+    ]),
+).sort();
+
+module.exports = lowercaseLocalPermutations;

package/src/intl/localeList.js

@@ -0,0 +1,110 @@
+/**
+ * This list is pulled from the main Prezly application. The underscores are replaced with dashes.
+ */
+module.exports = [
+    'af-ZA',
+    'ar',
+    'ar-AE',
+    'ar-BH',
+    'ar-QA',
+    'ar-SA',
+    'az',
+    'be',
+    'bg-BG',
+    'ca',
+    'cs-CZ',
+    'da-DK',
+    'de',
+    'de-DE',
+    'de-BE',
+    'de-AT',
+    'de-CH',
+    'el-GR',
+    'en',
+    'en-US',
+    'en-AE',
+    'en-AU',
+    'en-BD',
+    'en-BE',
+    'en-BH',
+    'en-CA',
+    'en-CN',
+    'en-DE',
+    'en-DK',
+    'en-GB',
+    'en-HK',
+    'en-ID',
+    'en-IE',
+    'en-IL',
+    'en-IN',
+    'en-JM',
+    'en-JP',
+    'en-KH',
+    'en-KR',
+    'en-LK',
+    'en-MV',
+    'en-MM',
+    'en-MY',
+    'en-NP',
+    'en-NZ',
+    'en-PH',
+    'en-PK',
+    'en-QA',
+    'en-SA',
+    'en-SG',
+    'en-TH',
+    'en-TW',
+    'en-VN',
+    'en-ZA',
+    'es',
+    'es-ES',
+    'es-MX',
+    'et-EE',
+    'es-419',
+    'fi-FI',
+    'fil',
+    'fr',
+    'fr-BE',
+    'fr-FR',
+    'fr-CA',
+    'fr-LU',
+    'ga-IE',
+    'he-IL',
+    'hi-IN',
+    'hr-HR',
+    'hu-HU',
+    'id-ID',
+    'it-IT',
+    'ja-JP',
+    'kk',
+    'ko-KR',
+    'ky',
+    'lt-LT',
+    'lv-LV',
+    'mt-MT',
+    'ms-MY',
+    'nb-NO',
+    'nl',
+    'nl-BE',
+    'nl-NL',
+    'pl-PL',
+    'pt',
+    'pt-BR',
+    'pt-PT',
+    'ro-RO',
+    'ru-RU',
+    'sk-SK',
+    'sl-SI',
+    'sv-SE',
+    'sw',
+    'th-TH',
+    'tr-TR',
+    'uk-UA',
+    'ur-PK',
+    'uz',
+    'vi-VN',
+    'zh-Hant',
+    'zh-HK',
+    'zh-TW',
+    'zh-CN',
+];

package/src/intl/localeObject.test.ts

@@ -0,0 +1,81 @@
+import { LocaleObject } from './localeObject';
+
+it('throws when created from invalid code', () => {
+    // @ts-expect-error
+    expect(() => new LocaleObject('en_US')).toThrow('Invalid locale code provided!');
+    // @ts-expect-error
+    expect(() => new LocaleObject('1234')).toThrow('Invalid locale code provided!');
+    // @ts-expect-error
+    expect(() => new LocaleObject('*!en-US')).toThrow('Invalid locale code provided!');
+});
+
+it('throws when created with unsupported code', () => {
+    const unsupportedCode = 'unknown-code';
+    expect(() => LocaleObject.fromAnyCode(unsupportedCode)).toThrow(
+        `Unsupported locale code provided: "${unsupportedCode}"`,
+    );
+});
+
+it('accepts any valid code type and converts it to hyphen code consistently', () => {
+    expect(LocaleObject.fromAnyCode('en').toHyphenCode()).toBe('en');
+    expect(LocaleObject.fromAnyCode('en-us').toHyphenCode()).toBe('en-US');
+    expect(LocaleObject.fromAnyCode('en-US').toHyphenCode()).toBe('en-US');
+    expect(LocaleObject.fromAnyCode('EN-US').toHyphenCode()).toBe('en-US');
+    expect(LocaleObject.fromAnyCode('en_us').toHyphenCode()).toBe('en-US');
+    expect(LocaleObject.fromAnyCode('en_US').toHyphenCode()).toBe('en-US');
+    expect(LocaleObject.fromAnyCode('EN_US').toHyphenCode()).toBe('en-US');
+
+    expect(LocaleObject.fromAnyCode('es-419').toHyphenCode()).toBe('es-419');
+    expect(LocaleObject.fromAnyCode('es_419').toHyphenCode()).toBe('es-419');
+});
+
+it('converts to underscore code consistently', () => {
+    expect(LocaleObject.fromAnyCode('en').toUnderscoreCode()).toBe('en');
+    expect(LocaleObject.fromAnyCode('en-us').toUnderscoreCode()).toBe('en_US');
+    expect(LocaleObject.fromAnyCode('en-US').toUnderscoreCode()).toBe('en_US');
+    expect(LocaleObject.fromAnyCode('EN-US').toUnderscoreCode()).toBe('en_US');
+    expect(LocaleObject.fromAnyCode('en_us').toUnderscoreCode()).toBe('en_US');
+    expect(LocaleObject.fromAnyCode('en_US').toUnderscoreCode()).toBe('en_US');
+    expect(LocaleObject.fromAnyCode('EN_US').toUnderscoreCode()).toBe('en_US');
+});
+
+it('converts to URL slug consistently', () => {
+    expect(LocaleObject.fromAnyCode('en').toUrlSlug()).toBe('en');
+    expect(LocaleObject.fromAnyCode('en-us').toUrlSlug()).toBe('en-us');
+    expect(LocaleObject.fromAnyCode('en-US').toUrlSlug()).toBe('en-us');
+    expect(LocaleObject.fromAnyCode('EN-US').toUrlSlug()).toBe('en-us');
+    expect(LocaleObject.fromAnyCode('en_us').toUrlSlug()).toBe('en-us');
+    expect(LocaleObject.fromAnyCode('en_US').toUrlSlug()).toBe('en-us');
+    expect(LocaleObject.fromAnyCode('EN_US').toUrlSlug()).toBe('en-us');
+});
+
+it('converts to neutral language code consistently', () => {
+    expect(LocaleObject.fromAnyCode('en').toNeutralLanguageCode()).toBe('en');
+    expect(LocaleObject.fromAnyCode('en-us').toNeutralLanguageCode()).toBe('en');
+    expect(LocaleObject.fromAnyCode('en-US').toNeutralLanguageCode()).toBe('en');
+    expect(LocaleObject.fromAnyCode('EN-US').toNeutralLanguageCode()).toBe('en');
+    expect(LocaleObject.fromAnyCode('en_us').toNeutralLanguageCode()).toBe('en');
+    expect(LocaleObject.fromAnyCode('en_US').toNeutralLanguageCode()).toBe('en');
+    expect(LocaleObject.fromAnyCode('EN_US').toNeutralLanguageCode()).toBe('en');
+});
+
+it('converts to region code consistently', () => {
+    expect(LocaleObject.fromAnyCode('en').toRegionCode()).toBe('EN');
+    expect(LocaleObject.fromAnyCode('en-us').toRegionCode()).toBe('US');
+    expect(LocaleObject.fromAnyCode('en-US').toRegionCode()).toBe('US');
+    expect(LocaleObject.fromAnyCode('EN-US').toRegionCode()).toBe('US');
+    expect(LocaleObject.fromAnyCode('en_us').toRegionCode()).toBe('US');
+    expect(LocaleObject.fromAnyCode('en_US').toRegionCode()).toBe('US');
+    expect(LocaleObject.fromAnyCode('EN_US').toRegionCode()).toBe('US');
+});
+
+it('can compare two objects', () => {
+    const enUsLocale = LocaleObject.fromAnyCode('en-US');
+    const enUsLocaleDuplicate = LocaleObject.fromAnyCode('en-US');
+    const deDeLocale = LocaleObject.fromAnyCode('de-DE');
+
+    expect(enUsLocale.isEqual(enUsLocaleDuplicate)).toBe(true);
+    expect(enUsLocaleDuplicate.isEqual(enUsLocale)).toBe(true);
+    expect(enUsLocale.isEqual(deDeLocale)).toBe(false);
+    expect(deDeLocale.isEqual(enUsLocale)).toBe(false);
+});