etudes 1.2.0 → 2.1.0

package/lib/providers/I18nProvider.d.ts

@@ -0,0 +1,179 @@
+import Polyglot from 'node-polyglot';
+import React, { Dispatch, PropsWithChildren } from 'react';
+interface Translation {
+    [key: string]: Translation | string;
+}
+type I18nState = {
+    changeLocaleStrategy: 'action' | 'path' | 'query';
+    defaultLocale: string;
+    locale: string;
+    polyglots: Record<string, Polyglot>;
+    supportedLocales: string[];
+    getLocalizedPath?: (path: string) => string;
+    getLocalizedString: typeof Polyglot.prototype.t;
+};
+type I18nContextValue = {
+    state: I18nState;
+    dispatch?: Dispatch<I18nChangeLocaleAction>;
+};
+type I18nProviderProps = PropsWithChildren<{
+    changeLocaleStrategy?: I18nState['changeLocaleStrategy'];
+    defaultLocale?: I18nState['defaultLocale'];
+    translations: Record<string, Translation>;
+}>;
+type I18nChangeLocaleAction = {
+    type: '@i18n/CHANGE_LOCALE';
+    locale: string;
+};
+export declare const I18nContext: React.Context<I18nContextValue | undefined>;
+/**
+ * Context provider whose value consists of the current i18n state. The method
+ * of modifying the locale is specified by `changeLocaleStrategy`, as follows:
+ *   - If set to `action`, the locale can be modified by dispatching an action
+ *   - If set to `path`, the locale is inferred from the current path name
+ *   - If set to `query`, the locale is inferred from the search parameter
+ *     `locale` in the current path
+ *
+ * @param props - See {@link I18nProviderProps}.
+ *
+ * @returns The context provider.
+ */
+export default function I18nProvider({ children, defaultLocale, translations, changeLocaleStrategy, }: I18nProviderProps): JSX.Element;
+/** @namespace Components */
+/**
+ * Custom {@link Routes} container that generates child {@link Route} components
+ * for all locales supported by {@link I18nProvider}.
+ */
+export declare function I18nRoutes({ children }: PropsWithChildren): JSX.Element;
+/** @namespace Hooks */
+/**
+ * Hook for retrieving the change locale function.
+ *
+ * @returns The change locale function.
+ */
+export declare function useChangeLocale(): (locale: string) => void | undefined;
+/**
+ * Hook for retrieving the current locale.
+ *
+ * @returns The current locale.
+ */
+export declare function useLocale(): string;
+/**
+ * Hook for retrieving the path localizing function for the current locale.
+ *
+ * @returns The path localizing function.
+ */
+export declare function useLocalizedPath(): (path: string) => string;
+/**
+ * Hook for retrieving the string localizing function for the current locale.
+ *
+ * @returns The string localizing function.
+ */
+export declare function useLocalizedString(): (phrase: string, options?: number | Polyglot.InterpolationOptions | undefined) => string;
+/**
+ * Hook for retrieving all supported locales.
+ *
+ * @returns All supported locales.
+ */
+export declare function useSupportedLocales(): string[];
+/** @namespace Utilities */
+type URLParts = {
+    base?: string;
+    hash?: string;
+    host?: string;
+    path?: string;
+    port?: string;
+    protocol?: string;
+    query?: string;
+};
+type ResolveLocaleOptions = {
+    /**
+     * The locale to fallback to if one cannot be inferred from the provided URL.
+     */
+    defaultLocale?: string;
+    /**
+     * An array of supported locales to validate the inferred locale against. If
+     * it doesn't exist in the list of supported locales, the default locale (if
+     * specified) or `undefined` will be returned.
+     */
+    supportedLocales?: string[];
+};
+type ResolveLocalizedURLOptions = ResolveLocaleOptions & {
+    /**
+     * Specifies where in the URL the locale should be matched. If `resolver` is
+     * provided, this option is ignored.
+     */
+    resolveStrategy?: 'auto' | 'domain' | 'path' | 'query';
+    /**
+     * Custom resolver function.
+     *
+     * @param protocol - The matched protocol of the provided url, if available.
+     * @param host - The matched host of the provided url, if available.
+     * @param port - The matched port of the provided url, if available.
+     * @param path - The matched path of the provided url, if available.
+     *
+     * @returns The resolved locale.
+     */
+    resolver?: (urlParts: URLParts) => string | undefined;
+};
+type LocalizedURLInfo = {
+    /**
+     * The matched locale.
+     */
+    locale: string;
+    /**
+     * Specifies where in the URL the locale was matched.
+     */
+    resolveStrategy: ResolveLocalizedURLOptions['resolveStrategy'] | 'custom';
+};
+/**
+ * Resolves the specified locale with the provided options. All parameters are
+ * optional.
+ *
+ * @param locale - The locale to resolve.
+ * @param options - See {@link ResolveLocaleOptions}.
+ *
+ * @returns - The resolved locale.
+ */
+export declare function resolveLocale(locale?: string, { defaultLocale, supportedLocales }?: ResolveLocaleOptions): string | undefined;
+/**
+ * Retrieves the locale identifier from a URL. The default behavior of this
+ * function to look for the locale identifier in the domain first followed by
+ * the first directory of the path. You can provide a custom resolver.
+ *
+ * @param url - The URL, can be a full URL or a valid path.
+ * @param options - See {@link ResolveLocalizedURLOptions}.
+ *
+ * @returns The inferred locale if it exists.
+ */
+export declare function getLocaleFromURL(url: string, { defaultLocale, resolveStrategy, resolver, supportedLocales }?: ResolveLocalizedURLOptions): LocalizedURLInfo | undefined;
+/**
+ * Returns the unlocalized version of a URL.
+ *
+ * @param url - The URL.
+ * @param options - See {@link ResolveLocalizedURLOptions}.
+ *
+ * @returns The unlocalized URL.
+ */
+export declare function getUnlocalizedURL(url: string, { resolveStrategy, resolver, supportedLocales }?: ResolveLocalizedURLOptions): string;
+/**
+ * Returns the localized version of a URL.
+ *
+ * @param url - The URL.
+ * @param locale - The target locale.
+ * @param options - See {@link ResolveLocalizedURLOptions}.
+ *
+ * @returns The localized URL.
+ */
+export declare function getLocalizedURL(url: string, locale: string, { defaultLocale, resolveStrategy, resolver, supportedLocales }?: ResolveLocalizedURLOptions): string;
+/**
+ * Returns all localized versions of a URL based on the specified
+ * `supportedLocales`.
+ *
+ * @param url - The URL.
+ * @param options - See {@link ResolveLocalizedURLOptions}.
+ *
+ * @returns The localized URLs.
+ */
+export declare function getLocalizedURLs(url: string, { defaultLocale, resolveStrategy, resolver, supportedLocales }?: ResolveLocalizedURLOptions): string[];
+export {};

package/lib/providers/I18nProvider.js

@@ -0,0 +1,470 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalizedURLs = exports.getLocalizedURL = exports.getUnlocalizedURL = exports.getLocaleFromURL = exports.resolveLocale = exports.useSupportedLocales = exports.useLocalizedString = exports.useLocalizedPath = exports.useLocale = exports.useChangeLocale = exports.I18nRoutes = exports.I18nContext = void 0;
+var node_polyglot_1 = __importDefault(require("node-polyglot"));
+var react_1 = __importStar(require("react"));
+var react_router_1 = require("react-router");
+var reducer = function (state, action) {
+    switch (action.type) {
+        case '@i18n/CHANGE_LOCALE':
+            return __assign(__assign({}, state), { locale: action.locale, getLocalizedString: function () {
+                    var _a, _b;
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    return (_b = (_a = state.polyglots[action.locale]) === null || _a === void 0 ? void 0 : _a.t.apply(_a, __spreadArray([], __read(args), false))) !== null && _b !== void 0 ? _b : args[0];
+                } });
+        default:
+            return state;
+    }
+};
+exports.I18nContext = (0, react_1.createContext)(undefined);
+/**
+ * Context provider whose value consists of the current i18n state. The method
+ * of modifying the locale is specified by `changeLocaleStrategy`, as follows:
+ *   - If set to `action`, the locale can be modified by dispatching an action
+ *   - If set to `path`, the locale is inferred from the current path name
+ *   - If set to `query`, the locale is inferred from the search parameter
+ *     `locale` in the current path
+ *
+ * @param props - See {@link I18nProviderProps}.
+ *
+ * @returns The context provider.
+ */
+function I18nProvider(_a) {
+    var _b;
+    var children = _a.children, _c = _a.defaultLocale, defaultLocale = _c === void 0 ? 'en' : _c, translations = _a.translations, _d = _a.changeLocaleStrategy, changeLocaleStrategy = _d === void 0 ? 'path' : _d;
+    var _e = (0, react_router_1.useLocation)(), pathname = _e.pathname, search = _e.search, hash = _e.hash;
+    var url = "".concat(pathname).concat(search).concat(hash);
+    var supportedLocales = Object.keys(translations);
+    if (supportedLocales.indexOf(defaultLocale) < 0) {
+        console.warn("Provided supported locales do not contain the default locale <".concat(defaultLocale, ">"));
+        supportedLocales.push(defaultLocale);
+    }
+    var polyglots = (0, react_1.useMemo)(function () { return supportedLocales.reduce(function (out, locale) {
+        var _a;
+        return (__assign(__assign({}, out), (_a = {}, _a[locale] = new node_polyglot_1.default({ locale: locale, phrases: translations[locale] }), _a)));
+    }, {}); }, [translations]);
+    switch (changeLocaleStrategy) {
+        case 'action': {
+            var _f = __read((0, react_1.useReducer)(reducer, {
+                changeLocaleStrategy: changeLocaleStrategy,
+                defaultLocale: defaultLocale,
+                locale: defaultLocale,
+                polyglots: polyglots,
+                supportedLocales: supportedLocales,
+                getLocalizedString: function () {
+                    var _a, _b;
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    return (_b = (_a = polyglots[defaultLocale]) === null || _a === void 0 ? void 0 : _a.t.apply(_a, __spreadArray([], __read(args), false))) !== null && _b !== void 0 ? _b : args[0];
+                },
+            }), 2), state = _f[0], dispatch = _f[1];
+            return (react_1.default.createElement(exports.I18nContext.Provider, { value: { state: state, dispatch: dispatch } }, children));
+        }
+        default: {
+            var resolveStrategy_1 = changeLocaleStrategy === 'path' ? 'path' : 'query';
+            var localeInfo = getLocaleFromURL(url, { defaultLocale: defaultLocale, resolveStrategy: resolveStrategy_1, supportedLocales: supportedLocales });
+            if (!localeInfo)
+                console.warn("Unable to infer locale from path <".concat(url, ">"));
+            var locale_1 = (_b = localeInfo === null || localeInfo === void 0 ? void 0 : localeInfo.locale) !== null && _b !== void 0 ? _b : defaultLocale;
+            var polyglot_1 = polyglots[locale_1];
+            if (!polyglot_1)
+                console.warn("Missing transtions for locale <".concat(locale_1, ">"));
+            var state = {
+                changeLocaleStrategy: changeLocaleStrategy,
+                defaultLocale: defaultLocale,
+                locale: locale_1,
+                polyglots: polyglots,
+                supportedLocales: supportedLocales,
+                getLocalizedPath: function (path) { return locale_1 === defaultLocale ? getUnlocalizedURL(path, { resolveStrategy: resolveStrategy_1, supportedLocales: supportedLocales }) : getLocalizedURL(path, locale_1, { defaultLocale: defaultLocale, resolveStrategy: changeLocaleStrategy, supportedLocales: supportedLocales }); },
+                getLocalizedString: function () {
+                    var _a;
+                    var args = [];
+                    for (var _i = 0; _i < arguments.length; _i++) {
+                        args[_i] = arguments[_i];
+                    }
+                    return (_a = polyglot_1 === null || polyglot_1 === void 0 ? void 0 : polyglot_1.t.apply(polyglot_1, __spreadArray([], __read(args), false))) !== null && _a !== void 0 ? _a : args[0];
+                },
+            };
+            return (react_1.default.createElement(exports.I18nContext.Provider, { value: { state: state } }, children));
+        }
+    }
+}
+exports.default = I18nProvider;
+/** @namespace Components */
+/**
+ * Custom {@link Routes} container that generates child {@link Route} components
+ * for all locales supported by {@link I18nProvider}.
+ */
+function I18nRoutes(_a) {
+    var children = _a.children;
+    var context = (0, react_1.useContext)(exports.I18nContext);
+    if (!context)
+        throw Error('Cannot fetch the value of I18nContext, is the corresponding provider instated?');
+    var _b = context.state, defaultLocale = _b.defaultLocale, supportedLocales = _b.supportedLocales, changeLocaleStrategy = _b.changeLocaleStrategy;
+    switch (changeLocaleStrategy) {
+        case 'path':
+            return (react_1.default.createElement(react_router_1.Routes, null, supportedLocales.map(function (locale) { return (react_1.default.createElement(react_router_1.Route, { key: locale, path: locale === defaultLocale ? '/' : locale }, children)); })));
+        default:
+            return (react_1.default.createElement(react_router_1.Routes, null,
+                react_1.default.createElement(react_router_1.Route, { path: '/' }, children)));
+    }
+}
+exports.I18nRoutes = I18nRoutes;
+/** @namespace Hooks */
+/**
+ * Hook for retrieving the change locale function.
+ *
+ * @returns The change locale function.
+ */
+function useChangeLocale() {
+    var context = (0, react_1.useContext)(exports.I18nContext);
+    if (!context)
+        throw Error('Cannot fetch the current i18n context, is the corresponding provider instated?');
+    if (context.state.changeLocaleStrategy === 'action') {
+        return function (locale) {
+            var _a;
+            return (_a = context.dispatch) === null || _a === void 0 ? void 0 : _a.call(context, {
+                locale: locale,
+                type: '@i18n/CHANGE_LOCALE',
+            });
+        };
+    }
+    else {
+        var _a = context.state, defaultLocale_1 = _a.defaultLocale, changeLocaleStrategy = _a.changeLocaleStrategy, supportedLocales_1 = _a.supportedLocales;
+        var _b = (0, react_router_1.useLocation)(), pathname = _b.pathname, search = _b.search, hash = _b.hash;
+        var path_1 = "".concat(pathname).concat(search).concat(hash);
+        var navigate_1 = (0, react_router_1.useNavigate)();
+        var resolveStrategy_2 = changeLocaleStrategy === 'path' ? 'path' : 'query';
+        return function (locale) {
+            var newPath = locale === defaultLocale_1
+                ? getUnlocalizedURL(path_1, { resolveStrategy: resolveStrategy_2, supportedLocales: supportedLocales_1 })
+                : getLocalizedURL(path_1, locale, { defaultLocale: defaultLocale_1, resolveStrategy: resolveStrategy_2, supportedLocales: supportedLocales_1 });
+            navigate_1(newPath);
+        };
+    }
+}
+exports.useChangeLocale = useChangeLocale;
+/**
+ * Hook for retrieving the current locale.
+ *
+ * @returns The current locale.
+ */
+function useLocale() {
+    var context = (0, react_1.useContext)(exports.I18nContext);
+    if (!context)
+        throw Error('Cannot fetch the current i18n context, is the corresponding provider instated?');
+    return context.state.locale;
+}
+exports.useLocale = useLocale;
+/**
+ * Hook for retrieving the path localizing function for the current locale.
+ *
+ * @returns The path localizing function.
+ */
+function useLocalizedPath() {
+    var _a;
+    var context = (0, react_1.useContext)(exports.I18nContext);
+    if (!context)
+        throw Error('Cannot fetch the current i18n context, is the corresponding provider instated?');
+    return (_a = context.state.getLocalizedPath) !== null && _a !== void 0 ? _a : (function (path) { return path; });
+}
+exports.useLocalizedPath = useLocalizedPath;
+/**
+ * Hook for retrieving the string localizing function for the current locale.
+ *
+ * @returns The string localizing function.
+ */
+function useLocalizedString() {
+    var context = (0, react_1.useContext)(exports.I18nContext);
+    if (!context)
+        throw Error('Cannot fetch the current i18n context, is the corresponding provider instated?');
+    return context.state.getLocalizedString;
+}
+exports.useLocalizedString = useLocalizedString;
+/**
+ * Hook for retrieving all supported locales.
+ *
+ * @returns All supported locales.
+ */
+function useSupportedLocales() {
+    var context = (0, react_1.useContext)(exports.I18nContext);
+    if (!context)
+        throw Error('Cannot fetch the current i18n context, is the corresponding provider instated?');
+    return context.state.supportedLocales;
+}
+exports.useSupportedLocales = useSupportedLocales;
+/**
+ * Parses a URL into parts.
+ *
+ * @param url - The URL to parse.
+ *
+ * @returns The parsed result.
+ */
+function parseURL(url) {
+    var regex = /((?:(.*):\/\/)?((?:[A-Za-z0-9-]+\.?)+)?(?::([0-9]+))?)([^?#]*)(?:\?([^#]*))?(?:#(.*))?/;
+    var parts = url.match(regex);
+    if (!parts)
+        return {};
+    return {
+        base: parts[1],
+        hash: parts[7],
+        host: parts[3],
+        path: parts[5],
+        port: parts[4],
+        protocol: parts[2],
+        query: parts[6],
+    };
+}
+/**
+ * Constructs a URL from {@link URLParts}.
+ *
+ * @param parts - See {@link URLParts}.
+ *
+ * @returns The constructed URL.
+ */
+function constructURL(parts) {
+    var _a, _b, _c, _d;
+    var protocol = (_b = (_a = parts.protocol) === null || _a === void 0 ? void 0 : _a.concat('://')) !== null && _b !== void 0 ? _b : '';
+    var host = (_d = (_c = parts.host) === null || _c === void 0 ? void 0 : _c.concat('/')) !== null && _d !== void 0 ? _d : '';
+    var port = parts.port ? ":".concat(parts.port) : '';
+    var path = parts.path ? "/".concat(parts.path.split('/').filter(function (t) { return t; }).join('/')) : '';
+    var query = parts.query ? "?".concat(parts.query) : '';
+    var hash = parts.hash ? "#".concat(parts.hash) : '';
+    return "".concat(protocol).concat(host).concat(port).concat(path).concat(query).concat(hash);
+}
+/**
+ * Resolves the specified locale with the provided options. All parameters are
+ * optional.
+ *
+ * @param locale - The locale to resolve.
+ * @param options - See {@link ResolveLocaleOptions}.
+ *
+ * @returns - The resolved locale.
+ */
+function resolveLocale(locale, _a) {
+    var _b = _a === void 0 ? {} : _a, defaultLocale = _b.defaultLocale, supportedLocales = _b.supportedLocales;
+    if (supportedLocales) {
+        if (locale && supportedLocales.indexOf(locale) >= 0)
+            return locale;
+        if (defaultLocale && supportedLocales.indexOf(defaultLocale) >= 0)
+            return defaultLocale;
+        return undefined;
+    }
+    return locale !== null && locale !== void 0 ? locale : defaultLocale;
+}
+exports.resolveLocale = resolveLocale;
+/**
+ * Retrieves the locale identifier from a URL. The default behavior of this
+ * function to look for the locale identifier in the domain first followed by
+ * the first directory of the path. You can provide a custom resolver.
+ *
+ * @param url - The URL, can be a full URL or a valid path.
+ * @param options - See {@link ResolveLocalizedURLOptions}.
+ *
+ * @returns The inferred locale if it exists.
+ */
+function getLocaleFromURL(url, _a) {
+    var _b, _c;
+    var _d = _a === void 0 ? {} : _a, defaultLocale = _d.defaultLocale, _e = _d.resolveStrategy, resolveStrategy = _e === void 0 ? 'auto' : _e, resolver = _d.resolver, supportedLocales = _d.supportedLocales;
+    var parts = parseURL(url);
+    if (resolver) {
+        var matchedLocale = resolver(parts);
+        if (matchedLocale && (!supportedLocales || supportedLocales.indexOf(matchedLocale) >= 0))
+            return { locale: matchedLocale, resolveStrategy: 'custom' };
+        if (defaultLocale && (!supportedLocales || supportedLocales.indexOf(defaultLocale) >= 0))
+            return { locale: defaultLocale, resolveStrategy: 'auto' };
+        return undefined;
+    }
+    else {
+        var matchedLocaleFromHost = (_b = parts.host) === null || _b === void 0 ? void 0 : _b.split('.').filter(function (t) { return t; })[0];
+        var matchedLocaleFromPath = (_c = parts.path) === null || _c === void 0 ? void 0 : _c.split('/').filter(function (t) { return t; })[0];
+        var matchedLocaleFromQuery = new URLSearchParams(parts.query).get('locale');
+        if (matchedLocaleFromHost && (resolveStrategy === 'auto' || resolveStrategy === 'domain') && (!supportedLocales || supportedLocales.indexOf(matchedLocaleFromHost) >= 0))
+            return { locale: matchedLocaleFromHost, resolveStrategy: 'domain' };
+        if (matchedLocaleFromPath && (resolveStrategy === 'auto' || resolveStrategy === 'path') && (!supportedLocales || supportedLocales.indexOf(matchedLocaleFromPath) >= 0))
+            return { locale: matchedLocaleFromPath, resolveStrategy: 'path' };
+        if (matchedLocaleFromQuery && (resolveStrategy === 'auto' || resolveStrategy === 'query') && (!supportedLocales || supportedLocales.indexOf(matchedLocaleFromQuery) >= 0))
+            return { locale: matchedLocaleFromQuery, resolveStrategy: 'query' };
+        if (defaultLocale && (!supportedLocales || supportedLocales.indexOf(defaultLocale) >= 0))
+            return { locale: defaultLocale, resolveStrategy: 'auto' };
+        return undefined;
+    }
+}
+exports.getLocaleFromURL = getLocaleFromURL;
+/**
+ * Returns the unlocalized version of a URL.
+ *
+ * @param url - The URL.
+ * @param options - See {@link ResolveLocalizedURLOptions}.
+ *
+ * @returns The unlocalized URL.
+ */
+function getUnlocalizedURL(url, _a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.resolveStrategy, resolveStrategy = _c === void 0 ? 'auto' : _c, resolver = _b.resolver, supportedLocales = _b.supportedLocales;
+    var currLocaleInfo = getLocaleFromURL(url, { resolveStrategy: resolveStrategy, resolver: resolver, supportedLocales: supportedLocales });
+    var parts = parseURL(url);
+    if (!currLocaleInfo)
+        return url;
+    switch (currLocaleInfo.resolveStrategy) {
+        case 'domain':
+            return constructURL(__assign(__assign({}, parts), { host: parts.host ? parts.host.split('.').filter(function (t) { return t; }).slice(1).join('.') : undefined }));
+        case 'query': {
+            if (!parts.query)
+                return url;
+            var searchParams = new URLSearchParams(parts.query);
+            searchParams.delete('locale');
+            return constructURL(__assign(__assign({}, parts), { query: searchParams.toString() }));
+        }
+        case 'path':
+        case 'auto':
+        default:
+            return constructURL(__assign(__assign({}, parts), { path: parts.path ? __spreadArray([], __read(parts.path.split('/').filter(function (t) { return t; }).slice(1)), false).join('/') : undefined }));
+    }
+}
+exports.getUnlocalizedURL = getUnlocalizedURL;
+/**
+ * Returns the localized version of a URL.
+ *
+ * @param url - The URL.
+ * @param locale - The target locale.
+ * @param options - See {@link ResolveLocalizedURLOptions}.
+ *
+ * @returns The localized URL.
+ */
+function getLocalizedURL(url, locale, _a) {
+    var _b = _a === void 0 ? {} : _a, defaultLocale = _b.defaultLocale, _c = _b.resolveStrategy, resolveStrategy = _c === void 0 ? 'auto' : _c, resolver = _b.resolver, supportedLocales = _b.supportedLocales;
+    var currLocaleInfo = getLocaleFromURL(url, { resolveStrategy: resolveStrategy, resolver: resolver, supportedLocales: supportedLocales });
+    var parts = parseURL(url);
+    var targetLocale = resolveLocale(locale, { defaultLocale: defaultLocale, supportedLocales: supportedLocales });
+    if (!targetLocale)
+        return url;
+    if (targetLocale === defaultLocale)
+        return getUnlocalizedURL(url, { resolveStrategy: resolveStrategy, resolver: resolver, supportedLocales: supportedLocales });
+    if (currLocaleInfo) {
+        switch (currLocaleInfo.resolveStrategy) {
+            case 'domain':
+                return constructURL(__assign(__assign({}, parts), { host: parts.host ? "".concat(targetLocale, ".").concat(parts.host.split('.').filter(function (t) { return t; }).slice(1).join('.')) : undefined }));
+            case 'query': {
+                if (!parts.query)
+                    return url;
+                var searchParams = new URLSearchParams(parts.query);
+                if (searchParams.get('locale')) {
+                    searchParams.set('locale', targetLocale);
+                }
+                else {
+                    searchParams.set('locale', targetLocale);
+                }
+                return constructURL(__assign(__assign({}, parts), { query: searchParams.toString() }));
+            }
+            case 'path':
+            case 'auto':
+            default:
+                return constructURL(__assign(__assign({}, parts), { path: parts.path ? __spreadArray([targetLocale], __read(parts.path.split('/').filter(function (t) { return t; }).slice(1)), false).join('/') : undefined }));
+        }
+    }
+    else {
+        switch (resolveStrategy) {
+            case 'domain':
+                return constructURL(__assign(__assign({}, parts), { host: parts.host ? "".concat(targetLocale, ".").concat(parts.host) : undefined }));
+            case 'query': {
+                var searchParams = new URLSearchParams(parts.query);
+                if (targetLocale === defaultLocale) {
+                    searchParams.delete('locale');
+                }
+                else {
+                    searchParams.set('locale', targetLocale);
+                }
+                return constructURL(__assign(__assign({}, parts), { query: searchParams.toString() }));
+            }
+            case 'path':
+            case 'auto':
+            default:
+                return constructURL(__assign(__assign({}, parts), { path: parts.path ? __spreadArray([targetLocale], __read(parts.path.split('/').filter(function (t) { return t; })), false).join('/') : undefined }));
+        }
+    }
+}
+exports.getLocalizedURL = getLocalizedURL;
+/**
+ * Returns all localized versions of a URL based on the specified
+ * `supportedLocales`.
+ *
+ * @param url - The URL.
+ * @param options - See {@link ResolveLocalizedURLOptions}.
+ *
+ * @returns The localized URLs.
+ */
+function getLocalizedURLs(url, _a) {
+    var _b = _a === void 0 ? {} : _a, defaultLocale = _b.defaultLocale, _c = _b.resolveStrategy, resolveStrategy = _c === void 0 ? 'auto' : _c, resolver = _b.resolver, supportedLocales = _b.supportedLocales;
+    if (!supportedLocales)
+        return [];
+    return supportedLocales.map(function (locale) { return getLocalizedURL(url, locale, { defaultLocale: defaultLocale, resolveStrategy: resolveStrategy, resolver: resolver, supportedLocales: supportedLocales }); });
+}
+exports.getLocalizedURLs = getLocalizedURLs;
+//# sourceMappingURL=I18nProvider.js.map