@jetshop/core 5.13.1 → 5.13.11-0

package/ChannelHandler/channelUtils.js

@@ -1,267 +1,267 @@
-import acceptLanguageParser from 'accept-language-parser';
-import qs from 'qs';
-export const getURLBasename = (url) => {
-    return url.pathname.split('/')[1];
-};
-export const getURLLanguageBasename = ({ url, singleDomainMode }) => {
-    if (singleDomainMode) {
-        return url.pathname.split('/')[2];
-    }
-    else {
-        return getURLBasename(url);
-    }
-};
-/**
- * Returns the default channel from a list of channels
- * @param channels List of channels to search through
- */
-export const getDefaultChannel = (channels) => {
-    return channels.find((channel) => channel.isDefault) || channels[0];
-};
-/**
- * Converts a Channel object to a SelectedChannel with the specified culture and currency
- * @param channel Channel to convert
- * @param culture Desired culture
- * @param currency Desired currency
- * @param country? Optional desired country code
- */
-export const createSelectedChannel = (channel, culture, currency, country, urlBasenameLanguage) => {
-    const selectedLanguage = channel.languages.find((language) => getLanguageFromCulture(language.culture) === urlBasenameLanguage) ||
-        channel.languages.find((language) => language.culture === culture) ||
-        channel.languages.find((language) => language.isDefault);
-    const selectedCurrency = channel.currencies.find((c) => c.id === currency) ||
-        channel.currencies.find((c) => c.isDefault);
-    // Set selectedCountry to the prop `country`, else use the default
-    const selectedCountry = channel.countries.find((c) => c.code === country) ||
-        channel.countries.find((c) => c.isDefault);
-    return Object.assign(Object.assign({}, channel), { currency: selectedCurrency || channel.defaultCurrency, language: selectedLanguage || channel.defaultLanguage, country: selectedCountry });
-};
-/**
- * Returns a channel with the specified name
- * @param channelName Name of the channel to be fond
- * @param channels Array of channels to search through
- */
-export const findChannel = (channelName, channels) => {
-    return channels.find((channel) => channel.name === channelName);
-};
-const sanitizeURL = (url) => String(url).replace(/^(?:[\w]+:\/\/)?(?:www\.)?/, '');
-export const findChannelById = (id, channels) => {
-    return channels.find((channel) => channel.id === id);
-};
-export const findChannelByCountry = (countryCode, channels) => {
-    // We want to give priority to channels that have the country we are looking for as a default country
-    const channelWithDefaultCountry = channels.find((channel) => channel.countries.find((country) => country.code === countryCode && country.isDefault)
-        ? true
-        : false);
-    if (!channelWithDefaultCountry) {
-        // If we don't find a channel with the default country then just return the first channel we find with that country
-        return channels.find((channel) => channel.countries.find((country) => country.code === countryCode)
-            ? true
-            : false);
-    }
-    else {
-        return channelWithDefaultCountry;
-    }
-};
-export const getQueryObject = (url) => {
-    const queryObject = qs.parse(new URL(url).search, {
-        ignoreQueryPrefix: true
-    });
-    // We want to make this property case insensitive
-    if (queryObject.redirectdisabled) {
-        queryObject.redirectDisabled = queryObject.redirectdisabled;
-    }
-    return queryObject;
-};
-export const setChannelCookies = ({ culture, currency, channelCountry, channel, redirectDisabled }, cookies) => {
-    const expires = new Date();
-    expires.setFullYear(new Date().getFullYear() + 10);
-    if (redirectDisabled) {
-        cookies.remove('culture');
-        cookies.remove('currency');
-        cookies.remove('country');
-        cookies.remove('channel');
-    }
-    culture && cookies.set('culture', culture, { expires, path: '/' });
-    currency && cookies.set('currency', currency, { expires, path: '/' });
-    channelCountry &&
-        cookies.set('country', channelCountry, { expires, path: '/' });
-    channel && cookies.set('channel', channel, { expires, path: '/' });
-};
-export function getLanguageFromCulture(culture) {
-    return culture.split('-')[0];
-}
-export function getChannelBasename(selectedChannel) {
-    const channelUrl = new URL(selectedChannel.url);
-    let languageSuffix;
-    if (!selectedChannel.language.isDefault) {
-        languageSuffix =
-            '/' + getLanguageFromCulture(selectedChannel.language.culture);
-    }
-    let basename;
-    if (channelUrl.pathname !== '/') {
-        basename = channelUrl.pathname + (languageSuffix || '');
-    }
-    else if (languageSuffix) {
-        basename = languageSuffix;
-    }
-    return basename;
-}
-export function isInDev(url) {
-    return (url.indexOf('localhost') >= 0 ||
-        url.indexOf('.dev.jetshop.se') >= 0 ||
-        process.env.NODE_ENV === 'development');
-}
-function getChannelFromPathOrUrl({ url, singleDomainMode, channels }) {
-    if (isInDev(url) && singleDomainMode) {
-        const basename = getURLBasename(new URL(url));
-        const activeChannels = channels.filter((channel) => basename === getURLBasename(new URL(channel.url)));
-        // If we find more than one active channel we will end up in an infinite redirect so we return the first channel
-        // This likely means that there are multiple channels with the same basename but different domains
-        // To handle channel switching on development we also return the activeChannels array
-        return {
-            activeChannel: activeChannels.length > 1 ? null : activeChannels[0],
-            activeChannels
-        };
-    }
-    else {
-        const currentUrl = sanitizeURL(url);
-        const sorted = channels.slice().sort((a, b) => b.url.length - a.url.length);
-        const activeChannels = sorted.filter((channel) => currentUrl.indexOf(sanitizeURL(channel.url)) === 0);
-        // If we find more than one active channel we will end up in an infinite redirect so we return false
-        // This likely means that there are multiple channels with the same domain
-        return {
-            activeChannel: activeChannels.length > 1 ? null : activeChannels[0],
-            activeChannels
-        };
-    }
-}
-function getChannelFromCookies({ cookies, channels }) {
-    const channelNameFromCookie = cookies.get('channel');
-    return findChannel(channelNameFromCookie, channels);
-}
-function setCookiesFromQueryString({ cookies, url }) {
-    // Get the culture, currency, country, channel from query string if set
-    const queryStringParams = getQueryObject(url);
-    // Set those values in to cookies
-    setChannelCookies(queryStringParams, cookies);
-}
-function getChannelFieldsFromCookies(cookies) {
-    const cultureFromCookie = cookies.get('culture');
-    const currencyFromCookie = cookies.get('currency');
-    const countryFromCookie = cookies.get('country');
-    const geoipCountryFromCookie = cookies.get('geoipCountry');
-    const acceptLanguageCultureFromCookie = cookies.get('acceptLanguageCulture');
-    return {
-        cultureFromCookie: cultureFromCookie || acceptLanguageCultureFromCookie,
-        currencyFromCookie,
-        countryFromCookie: countryFromCookie || geoipCountryFromCookie
-    };
-}
-function getCultureFromAcceptLanguages({ channel, acceptedLanguages }) {
-    const acceptedLanguagesString = typeof acceptedLanguages !== 'string'
-        ? acceptedLanguages[0]
-        : acceptedLanguages;
-    const channelLanguages = channel.languages.map((language) => language.culture);
-    return (acceptedLanguages &&
-        acceptLanguageParser.pick(channelLanguages, acceptedLanguagesString));
-}
-function setGeoIpAndAcceptLanguageCookies({ cookies, geoipCountry, acceptLanguageCulture }) {
-    const expires = new Date();
-    expires.setFullYear(new Date().getFullYear() + 10);
-    geoipCountry &&
-        cookies.set('geoipCountry', geoipCountry, { expires, path: '/' });
-    acceptLanguageCulture &&
-        cookies.set('acceptLanguageCulture', acceptLanguageCulture, {
-            expires,
-            path: '/'
-        });
-}
-export function getSelectedAndRecommendedChannel({ url, singleDomainMode, channels, cookies, geoipCountry, acceptedLanguages, disableGeoRedirect }) {
-    setCookiesFromQueryString({ cookies, url });
-    const { activeChannel, activeChannels } = getChannelFromPathOrUrl({
-        url,
-        singleDomainMode,
-        channels
-    });
-    const chosenChannel = getChannelFromCookies({
-        cookies,
-        channels
-    });
-    const defaultChannel = getDefaultChannel(channels);
-    // Active channel is given first priority. If it is null we are most likely in staging or development so chosenChannel or defaultChannel is used
-    const pureChannel = activeChannel || chosenChannel || defaultChannel;
-    let redirect = false;
-    const channelFromGeoIp = findChannelByCountry(geoipCountry || cookies.get('geoipCountry'), channels);
-    let pureRecommendedChannel;
-    // If a channel has been chosen we want to redirect to it
-    if (chosenChannel &&
-        activeChannel &&
-        activeChannel.id !== chosenChannel.id &&
-        // We don't want to redirect if the URLs of the channels are the same (i.e. demostore)
-        chosenChannel.url !== activeChannel.url) {
-        redirect = true;
-        pureRecommendedChannel = chosenChannel;
-    }
-    else if (pureChannel &&
-        channelFromGeoIp &&
-        pureChannel.id !== channelFromGeoIp.id) {
-        pureRecommendedChannel = channelFromGeoIp;
-        redirect = !disableGeoRedirect && !chosenChannel;
-        // this should happen when we can't find a matching channel from the url so we want to redirect such that the basename is included
-    }
-    else if (!activeChannel &&
-        singleDomainMode &&
-        activeChannels.length === 0) {
-        redirect = true;
-        pureRecommendedChannel = pureChannel;
-    }
-    // disable all redirects if either redirectDisabled or articlenumber (product previews) is in the query string
-    const { redirectDisabled, articlenumber } = getQueryObject(url);
-    if (redirectDisabled || articlenumber) {
-        redirect = false;
-    }
-    // This should only happen on the server. We do this because we need to know the channel languages before we can determine accept language culture
-    const acceptLanguageCulture = acceptedLanguages &&
-        getCultureFromAcceptLanguages({
-            channel: pureChannel,
-            acceptedLanguages
-        });
-    // set geoip and acceptLanguage as cookies so we can retrieve them on the client
-    setGeoIpAndAcceptLanguageCookies({
-        cookies,
-        geoipCountry,
-        acceptLanguageCulture
-    });
-    const { cultureFromCookie, currencyFromCookie, countryFromCookie } = getChannelFieldsFromCookies(cookies);
-    const urlBasenameLanguage = getURLLanguageBasename({
-        url: new URL(url),
-        singleDomainMode
-    });
-    const selectedChannel = createSelectedChannel(pureChannel, cultureFromCookie, currencyFromCookie, countryFromCookie, urlBasenameLanguage);
-    if (!selectedChannel.language.isDefault &&
-        getLanguageFromCulture(selectedChannel.language.culture) !==
-            urlBasenameLanguage) {
-        redirect = true;
-        pureRecommendedChannel = pureChannel;
-    }
-    const recommendedChannel = pureRecommendedChannel &&
-        createSelectedChannel(pureRecommendedChannel, cultureFromCookie, currencyFromCookie, countryFromCookie, urlBasenameLanguage);
-    return {
-        redirect,
-        selectedChannel,
-        recommendedChannel
-    };
-}
-export function getChannelHeaders(channel) {
-    return channel
-        ? {
-            currency: channel.currency.id,
-            channelid: channel.id,
-            culture: channel.language.culture,
-            country: channel.country.code,
-            name: channel.name
-        }
-        : {};
-}
+import acceptLanguageParser from 'accept-language-parser';
+import qs from 'qs';
+export const getURLBasename = (url) => {
+    return url.pathname.split('/')[1];
+};
+export const getURLLanguageBasename = ({ url, singleDomainMode }) => {
+    if (singleDomainMode) {
+        return url.pathname.split('/')[2];
+    }
+    else {
+        return getURLBasename(url);
+    }
+};
+/**
+ * Returns the default channel from a list of channels
+ * @param channels List of channels to search through
+ */
+export const getDefaultChannel = (channels) => {
+    return channels.find((channel) => channel.isDefault) || channels[0];
+};
+/**
+ * Converts a Channel object to a SelectedChannel with the specified culture and currency
+ * @param channel Channel to convert
+ * @param culture Desired culture
+ * @param currency Desired currency
+ * @param country? Optional desired country code
+ */
+export const createSelectedChannel = (channel, culture, currency, country, urlBasenameLanguage) => {
+    const selectedLanguage = channel.languages.find((language) => getLanguageFromCulture(language.culture) === urlBasenameLanguage) ||
+        channel.languages.find((language) => language.culture === culture) ||
+        channel.languages.find((language) => language.isDefault);
+    const selectedCurrency = channel.currencies.find((c) => c.id === currency) ||
+        channel.currencies.find((c) => c.isDefault);
+    // Set selectedCountry to the prop `country`, else use the default
+    const selectedCountry = channel.countries.find((c) => c.code === country) ||
+        channel.countries.find((c) => c.isDefault);
+    return Object.assign(Object.assign({}, channel), { currency: selectedCurrency || channel.defaultCurrency, language: selectedLanguage || channel.defaultLanguage, country: selectedCountry });
+};
+/**
+ * Returns a channel with the specified name
+ * @param channelName Name of the channel to be fond
+ * @param channels Array of channels to search through
+ */
+export const findChannel = (channelName, channels) => {
+    return channels.find((channel) => channel.name === channelName);
+};
+const sanitizeURL = (url) => String(url).replace(/^(?:[\w]+:\/\/)?(?:www\.)?/, '');
+export const findChannelById = (id, channels) => {
+    return channels.find((channel) => channel.id === id);
+};
+export const findChannelByCountry = (countryCode, channels) => {
+    // We want to give priority to channels that have the country we are looking for as a default country
+    const channelWithDefaultCountry = channels.find((channel) => channel.countries.find((country) => country.code === countryCode && country.isDefault)
+        ? true
+        : false);
+    if (!channelWithDefaultCountry) {
+        // If we don't find a channel with the default country then just return the first channel we find with that country
+        return channels.find((channel) => channel.countries.find((country) => country.code === countryCode)
+            ? true
+            : false);
+    }
+    else {
+        return channelWithDefaultCountry;
+    }
+};
+export const getQueryObject = (url) => {
+    const queryObject = qs.parse(new URL(url).search, {
+        ignoreQueryPrefix: true
+    });
+    // We want to make this property case insensitive
+    if (queryObject.redirectdisabled) {
+        queryObject.redirectDisabled = queryObject.redirectdisabled;
+    }
+    return queryObject;
+};
+export const setChannelCookies = ({ culture, currency, channelCountry, channel, redirectDisabled }, cookies) => {
+    const expires = new Date();
+    expires.setFullYear(new Date().getFullYear() + 10);
+    if (redirectDisabled) {
+        cookies.remove('culture');
+        cookies.remove('currency');
+        cookies.remove('country');
+        cookies.remove('channel');
+    }
+    culture && cookies.set('culture', culture, { expires, path: '/' });
+    currency && cookies.set('currency', currency, { expires, path: '/' });
+    channelCountry &&
+        cookies.set('country', channelCountry, { expires, path: '/' });
+    channel && cookies.set('channel', channel, { expires, path: '/' });
+};
+export function getLanguageFromCulture(culture) {
+    return culture.split('-')[0];
+}
+export function getChannelBasename(selectedChannel) {
+    const channelUrl = new URL(selectedChannel.url);
+    let languageSuffix;
+    if (!selectedChannel.language.isDefault) {
+        languageSuffix =
+            '/' + getLanguageFromCulture(selectedChannel.language.culture);
+    }
+    let basename;
+    if (channelUrl.pathname !== '/') {
+        basename = channelUrl.pathname + (languageSuffix || '');
+    }
+    else if (languageSuffix) {
+        basename = languageSuffix;
+    }
+    return basename;
+}
+export function isInDev(url) {
+    return (url.indexOf('localhost') >= 0 ||
+        url.indexOf('.dev.jetshop.se') >= 0 ||
+        process.env.NODE_ENV === 'development');
+}
+function getChannelFromPathOrUrl({ url, singleDomainMode, channels }) {
+    if (isInDev(url) && singleDomainMode) {
+        const basename = getURLBasename(new URL(url));
+        const activeChannels = channels.filter((channel) => basename === getURLBasename(new URL(channel.url)));
+        // If we find more than one active channel we will end up in an infinite redirect so we return the first channel
+        // This likely means that there are multiple channels with the same basename but different domains
+        // To handle channel switching on development we also return the activeChannels array
+        return {
+            activeChannel: activeChannels.length > 1 ? null : activeChannels[0],
+            activeChannels
+        };
+    }
+    else {
+        const currentUrl = sanitizeURL(url);
+        const sorted = channels.slice().sort((a, b) => b.url.length - a.url.length);
+        const activeChannels = sorted.filter((channel) => currentUrl.indexOf(sanitizeURL(channel.url)) === 0);
+        // If we find more than one active channel we will end up in an infinite redirect so we return false
+        // This likely means that there are multiple channels with the same domain
+        return {
+            activeChannel: activeChannels.length > 1 ? null : activeChannels[0],
+            activeChannels
+        };
+    }
+}
+function getChannelFromCookies({ cookies, channels }) {
+    const channelNameFromCookie = cookies.get('channel');
+    return findChannel(channelNameFromCookie, channels);
+}
+function setCookiesFromQueryString({ cookies, url }) {
+    // Get the culture, currency, country, channel from query string if set
+    const queryStringParams = getQueryObject(url);
+    // Set those values in to cookies
+    setChannelCookies(queryStringParams, cookies);
+}
+function getChannelFieldsFromCookies(cookies) {
+    const cultureFromCookie = cookies.get('culture');
+    const currencyFromCookie = cookies.get('currency');
+    const countryFromCookie = cookies.get('country');
+    const geoipCountryFromCookie = cookies.get('geoipCountry');
+    const acceptLanguageCultureFromCookie = cookies.get('acceptLanguageCulture');
+    return {
+        cultureFromCookie: cultureFromCookie || acceptLanguageCultureFromCookie,
+        currencyFromCookie,
+        countryFromCookie: countryFromCookie || geoipCountryFromCookie
+    };
+}
+function getCultureFromAcceptLanguages({ channel, acceptedLanguages }) {
+    const acceptedLanguagesString = typeof acceptedLanguages !== 'string'
+        ? acceptedLanguages[0]
+        : acceptedLanguages;
+    const channelLanguages = channel.languages.map((language) => language.culture);
+    return (acceptedLanguages &&
+        acceptLanguageParser.pick(channelLanguages, acceptedLanguagesString));
+}
+function setGeoIpAndAcceptLanguageCookies({ cookies, geoipCountry, acceptLanguageCulture }) {
+    const expires = new Date();
+    expires.setFullYear(new Date().getFullYear() + 10);
+    geoipCountry &&
+        cookies.set('geoipCountry', geoipCountry, { expires, path: '/' });
+    acceptLanguageCulture &&
+        cookies.set('acceptLanguageCulture', acceptLanguageCulture, {
+            expires,
+            path: '/'
+        });
+}
+export function getSelectedAndRecommendedChannel({ url, singleDomainMode, channels, cookies, geoipCountry, acceptedLanguages, disableGeoRedirect }) {
+    setCookiesFromQueryString({ cookies, url });
+    const { activeChannel, activeChannels } = getChannelFromPathOrUrl({
+        url,
+        singleDomainMode,
+        channels
+    });
+    const chosenChannel = getChannelFromCookies({
+        cookies,
+        channels
+    });
+    const defaultChannel = getDefaultChannel(channels);
+    // Active channel is given first priority. If it is null we are most likely in staging or development so chosenChannel or defaultChannel is used
+    const pureChannel = activeChannel || chosenChannel || defaultChannel;
+    let redirect = false;
+    const channelFromGeoIp = findChannelByCountry(geoipCountry || cookies.get('geoipCountry'), channels);
+    let pureRecommendedChannel;
+    // If a channel has been chosen we want to redirect to it
+    if (chosenChannel &&
+        activeChannel &&
+        activeChannel.id !== chosenChannel.id &&
+        // We don't want to redirect if the URLs of the channels are the same (i.e. demostore)
+        chosenChannel.url !== activeChannel.url) {
+        redirect = true;
+        pureRecommendedChannel = chosenChannel;
+    }
+    else if (pureChannel &&
+        channelFromGeoIp &&
+        pureChannel.id !== channelFromGeoIp.id) {
+        pureRecommendedChannel = channelFromGeoIp;
+        redirect = !disableGeoRedirect && !chosenChannel;
+        // this should happen when we can't find a matching channel from the url so we want to redirect such that the basename is included
+    }
+    else if (!activeChannel &&
+        singleDomainMode &&
+        activeChannels.length === 0) {
+        redirect = true;
+        pureRecommendedChannel = pureChannel;
+    }
+    // disable all redirects if either redirectDisabled or articlenumber (product previews) is in the query string
+    const { redirectDisabled, articlenumber } = getQueryObject(url);
+    if (redirectDisabled || articlenumber) {
+        redirect = false;
+    }
+    // This should only happen on the server. We do this because we need to know the channel languages before we can determine accept language culture
+    const acceptLanguageCulture = acceptedLanguages &&
+        getCultureFromAcceptLanguages({
+            channel: pureChannel,
+            acceptedLanguages
+        });
+    // set geoip and acceptLanguage as cookies so we can retrieve them on the client
+    setGeoIpAndAcceptLanguageCookies({
+        cookies,
+        geoipCountry,
+        acceptLanguageCulture
+    });
+    const { cultureFromCookie, currencyFromCookie, countryFromCookie } = getChannelFieldsFromCookies(cookies);
+    const urlBasenameLanguage = getURLLanguageBasename({
+        url: new URL(url),
+        singleDomainMode
+    });
+    const selectedChannel = createSelectedChannel(pureChannel, cultureFromCookie, currencyFromCookie, countryFromCookie, urlBasenameLanguage);
+    if (!selectedChannel.language.isDefault &&
+        getLanguageFromCulture(selectedChannel.language.culture) !==
+            urlBasenameLanguage) {
+        redirect = true;
+        pureRecommendedChannel = pureChannel;
+    }
+    const recommendedChannel = pureRecommendedChannel &&
+        createSelectedChannel(pureRecommendedChannel, cultureFromCookie, currencyFromCookie, countryFromCookie, urlBasenameLanguage);
+    return {
+        redirect,
+        selectedChannel,
+        recommendedChannel
+    };
+}
+export function getChannelHeaders(channel) {
+    return channel
+        ? {
+            currency: channel.currency.id,
+            channelid: channel.id,
+            culture: channel.language.culture,
+            country: channel.country.code,
+            name: channel.name
+        }
+        : {};
+}
 //# sourceMappingURL=channelUtils.js.map

package/ChannelHandler/redirectUtils.d.ts

@@ -1,4 +1,4 @@
-import ApolloClient from 'apollo-client';
-import { SelectedChannel } from '../components/ChannelContext/ChannelContext';
-export declare type GetPrimaryRoutePath = (path: string, newChannel: SelectedChannel, setSelectedChannel: (selectedChannel: SelectedChannel) => void) => Promise<string>;
-export declare function primaryRouteForPathFetcher(client: ApolloClient<any>): GetPrimaryRoutePath;
+import ApolloClient from 'apollo-client';
+import { SelectedChannel } from '../components/ChannelContext/ChannelContext';
+export declare type GetPrimaryRoutePath = (path: string, newChannel: SelectedChannel, setSelectedChannel: (selectedChannel: SelectedChannel) => void) => Promise<string>;
+export declare function primaryRouteForPathFetcher(client: ApolloClient<any>): GetPrimaryRoutePath;

package/ChannelHandler/redirectUtils.js

@@ -1,50 +1,50 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import preserveRedirectRouteQuery from './PreserveRedirectRouteQuery.gql';
-import ProductPathnameRedirectQuery from './ProductPathnameRedirectQuery.gql';
-import CategoryPathnameRedirectQuery from './CategoryPathnameRedirectQuery.gql';
-import StartPagePathnameRedirectQuery from './StartPagePathnameRedirectQuery.gql';
-import PagePathnameRedirectQuery from './PagePathnameRedirectQuery.gql';
-const PathnameRedirectQueryMap = {
-    Product: ProductPathnameRedirectQuery,
-    Category: CategoryPathnameRedirectQuery,
-    StartPage: StartPagePathnameRedirectQuery,
-    Page: PagePathnameRedirectQuery
-};
-export function primaryRouteForPathFetcher(client) {
-    return (path, newChannel, setSelectedChannel) => __awaiter(this, void 0, void 0, function* () {
-        try {
-            if (!path) {
-                throw new Error('No path was provided');
-            }
-            const routeQueryResult = yield client.query({
-                query: preserveRedirectRouteQuery,
-                variables: {
-                    path
-                }
-            });
-            const { id, __typename, pageId } = routeQueryResult.data.route.object;
-            const idUesdForRedirect = id || pageId;
-            setSelectedChannel(newChannel);
-            const pathnameQueryResult = yield client.query({
-                fetchPolicy: 'network-only',
-                query: PathnameRedirectQueryMap[__typename],
-                variables: {
-                    id: idUesdForRedirect
-                }
-            });
-            return pathnameQueryResult.data[__typename].primaryRoute.path;
-        }
-        catch (e) {
-            return '/';
-        }
-    });
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import preserveRedirectRouteQuery from './PreserveRedirectRouteQuery.gql';
+import ProductPathnameRedirectQuery from './ProductPathnameRedirectQuery.gql';
+import CategoryPathnameRedirectQuery from './CategoryPathnameRedirectQuery.gql';
+import StartPagePathnameRedirectQuery from './StartPagePathnameRedirectQuery.gql';
+import PagePathnameRedirectQuery from './PagePathnameRedirectQuery.gql';
+const PathnameRedirectQueryMap = {
+    Product: ProductPathnameRedirectQuery,
+    Category: CategoryPathnameRedirectQuery,
+    StartPage: StartPagePathnameRedirectQuery,
+    Page: PagePathnameRedirectQuery
+};
+export function primaryRouteForPathFetcher(client) {
+    return (path, newChannel, setSelectedChannel) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (!path) {
+                throw new Error('No path was provided');
+            }
+            const routeQueryResult = yield client.query({
+                query: preserveRedirectRouteQuery,
+                variables: {
+                    path
+                }
+            });
+            const { id, __typename, pageId } = routeQueryResult.data.route.object;
+            const idUesdForRedirect = id || pageId;
+            setSelectedChannel(newChannel);
+            const pathnameQueryResult = yield client.query({
+                fetchPolicy: 'network-only',
+                query: PathnameRedirectQueryMap[__typename],
+                variables: {
+                    id: idUesdForRedirect
+                }
+            });
+            return pathnameQueryResult.data[__typename].primaryRoute.path;
+        }
+        catch (e) {
+            return '/';
+        }
+    });
+}
 //# sourceMappingURL=redirectUtils.js.map