@zengenti/contensis-react-base 4.0.0-beta.9 → 4.0.1-beta.0

package/esm/{App-DLZweVSp.js → App-Bplaqueq.js}

@@ -1,21 +1,89 @@
 import { createBrowserHistory, createMemoryHistory } from 'history';
-import { takeEvery, select, put, call, all } from '@redux-saga/core/effects';
+import { takeEvery, select, put, call, cancel, fork, take, cancelled, all } from '@redux-saga/core/effects';
 import * as log from 'loglevel';
-import { G as GET_NODE_TREE, b as SET_NODE_TREE, d as GET_NODE_TREE_ERROR } from './store-3u0RzHZ0.js';
-import { h as hasNavigationTree, i as injectRedux } from './version-BlsI7hX2.js';
+import { error as error$1 } from 'loglevel';
+import { G as GET_NODE_TREE, b as SET_NODE_TREE, d as GET_NODE_TREE_ERROR } from './store-B4IrBYHm.js';
+import { h as hasNavigationTree, b as injectRedux } from './version-CA9Mdm3A.js';
 import to, { to as to$1 } from 'await-to-js';
-import { y as SET_NAVIGATION_PATH, x as SET_ROUTE, h as selectRouteEntry, C as selectCurrentNode, n as selectCurrentProject, z as UPDATE_LOADING_STATE, D as selectCurrentAncestors, E as selectCurrentSiblings, F as selectRouteEntryEntryId, G as selectRouteEntryLanguage, m as selectMappedEntry, A as SET_ENTRY, B as SET_ANCESTORS, w as SET_SIBLINGS, R as REGISTER_USER, H as REGISTER_USER_SUCCESS, I as REGISTER_USER_FAILED, J as queryParams, K as selectCurrentSearch, L as setRoute, M as REQUEST_USER_PASSWORD_RESET, N as RESET_USER_PASSWORD, O as CHANGE_USER_PASSWORD, P as REQUEST_USER_PASSWORD_RESET_SENDING, Q as REQUEST_USER_PASSWORD_RESET_SUCCESS, T as REQUEST_USER_PASSWORD_RESET_ERROR, V as RESET_USER_PASSWORD_SENDING, W as RESET_USER_PASSWORD_SUCCESS, X as RESET_USER_PASSWORD_ERROR, Y as CHANGE_USER_PASSWORD_ERROR, Z as CHANGE_USER_PASSWORD_SENDING, _ as CHANGE_USER_PASSWORD_SUCCESS } from './selectors-DO2ocdOp.js';
-import { s as selectVersionStatus } from './version-wnf-TITV.js';
-import { h as handleRequiresLoginSaga, L as LoginHelper, i as findContentTypeMapping, j as getManagementApiClient, k as loginSagas } from './ChangePassword.container-BgzIy8dA.js';
+import { eventChannel } from 'redux-saga';
+import { Query, Op } from 'contensis-delivery-api';
+import { a as actions } from './slice-C6JLQik8.js';
+import { o as selectCurrentPath, G as setRoute, K as selectRouteEntryAvailableLanguages, M as selectRouteEntryID, N as selectStaticRoute, y as SET_NAVIGATION_PATH, x as SET_ROUTE, j as selectRouteEntry, O as selectCurrentNode, f as selectCurrentProject, z as UPDATE_LOADING_STATE, P as selectCurrentAncestors, Q as selectCurrentSiblings, T as selectRouteEntryEntryId, W as selectRouteEntryLanguage, n as selectMappedEntry, A as SET_ENTRY, B as SET_ANCESTORS, w as SET_SIBLINGS, R as REGISTER_USER, X as REGISTER_USER_SUCCESS, Y as REGISTER_USER_FAILED, E as queryParams, F as selectCurrentSearch, H as REQUEST_USER_PASSWORD_RESET, I as RESET_USER_PASSWORD, J as CHANGE_USER_PASSWORD, Z as REQUEST_USER_PASSWORD_RESET_SENDING, _ as REQUEST_USER_PASSWORD_RESET_SUCCESS, $ as REQUEST_USER_PASSWORD_RESET_ERROR, a0 as RESET_USER_PASSWORD_SENDING, a1 as RESET_USER_PASSWORD_SUCCESS, a2 as RESET_USER_PASSWORD_ERROR, a3 as CHANGE_USER_PASSWORD_ERROR, a4 as CHANGE_USER_PASSWORD_SENDING, a5 as CHANGE_USER_PASSWORD_SUCCESS } from './selectors-8ROQrTd7.js';
+import { s as selectVersionStatus } from './version-BQAL8sQO.js';
+import { c as cachedSearch } from './ContensisDeliveryApi-LWYXevZ1.js';
 import React from 'react';
 import 'react-cookie';
 import 'react-redux';
+import './VersionInfo-By2ZCZOh.js';
+import 'react-helmet-async';
 import 'jsonpath-mapper';
-import { Op, Query } from 'contensis-delivery-api';
-import { l as selectClientCredentials } from './ToJs-CNzfvyxJ.js';
-import 'query-string';
 import 'react-router-dom';
-import { a as RouteLoader } from './RouteLoader-xeQBXywk.js';
+import { s as selectCurrentLanguage, a as selectDictionary, c as selectLocaleRoutes, b as selectLocales, f as selectDictionaryResolver, d as selectPrimaryLanguage } from './selectors-DcmvOeX2.js';
+import { i as findContentTypeMapping, h as handleRequiresLoginSaga, L as LoginHelper, j as getSearchOptions, k as getManagementApiClient, m as loginSagas } from './ChangePassword.container-CUBtn82K.js';
+import './sagas-Fr9yRduO.js';
+import 'reselect';
+import 'immer';
+import 'deep-equal';
+import 'deepmerge';
+import { r as routeParams } from './util-Bl2u6LpY.js';
+import 'contensis-core-api';
+import { l as selectClientCredentials } from './matchGroups-_w8BwzCC.js';
+import { a as RouteLoader } from './RouteLoader-CzrlySZf.js';
+import 'query-string';
+
+const isApiError = e => !!e && typeof e === 'object' && 'status' in e && 'statusText' in e;
+const isPlainError = e => !!e && typeof e === 'object' && 'message' in e && typeof e.message === 'string';
+const logError = (prefix, e) => {
+  var _e$data;
+  const message = isApiError(e) ? `${prefix} ${e.status} "${((_e$data = e.data) === null || _e$data === void 0 ? void 0 : _e$data.message) || ''}" url: ${e.url || ''}` : isPlainError(e) ? `${prefix} "${(e === null || e === void 0 ? void 0 : e.message) || e}"${e !== null && e !== void 0 && e.stack ? `\n${e.stack}` : ''}` : `${prefix} "${e}"`;
+  error$1(message);
+};
+const shorten = (str, maxLength = 120, endWeight = 0.6) => {
+  if (!str || str.length <= maxLength) return str;
+  const charsToShow = maxLength - 3;
+  const back = Math.floor(charsToShow * endWeight);
+  const front = charsToShow - back;
+  return `${str.slice(0, front)}...${str.slice(str.length - back)}`;
+};
+
+const deparameterise = path => {
+  return path.replace(/\/:\w+\??/g, '');
+};
+
+/** Create static routes for routes with specified locales */
+const createLocaleRoutes = routes => {
+  const localeRoutes = {};
+  for (const route of routes.StaticRoutes) {
+    // If the route has defined locales, create entries for each locale
+    if (route.i18n && route.path) {
+      for (const [language, path] of Object.entries(route.i18n)) {
+        // We already have a locale route, so just append the language and path
+        const deparameterisedPath = deparameterise(route.path);
+        const deparameterisedLocalePath = deparameterise(path);
+        if (localeRoutes[deparameterisedPath]) localeRoutes[deparameterisedPath][language] = deparameterisedLocalePath;
+        // Otherwise, create a new entry for this route path
+        else localeRoutes[deparameterisedPath] = {
+          [language]: deparameterisedLocalePath
+        };
+        if (deparameterise(route.path) !== deparameterisedLocalePath) {
+          // I think we are OK to mutate here as this is only run once on app init
+          // we can change this if needed later
+          routes.StaticRoutes.push({
+            ...route,
+            path,
+            // Add the path with any parameters included
+            language,
+            i18n: undefined
+          });
+        } else {
+          // Just set the language on the existing route instead of creating a duplicate
+          route.language = language;
+        }
+      }
+    }
+  }
+  return localeRoutes;
+};
 
 // Create a history depending on the environment
 const selectedHistory = typeof window !== 'undefined' ? createBrowserHistory : createMemoryHistory;
@@ -29,12 +97,17 @@ function* ensureNodeTreeSaga(action) {
     language,
     project,
     versionStatus,
+    subsitePath,
     treeDepth
   } = action;
   const state = yield select();
   try {
     if (!hasNavigationTree(state)) {
-      const nodes = yield api.getRootNode({
+      const nodes = subsitePath ? yield api.getNode({
+        path: subsitePath,
+        depth: treeDepth || 0,
+        language
+      }, project) : yield api.getRootNode({
         depth: treeDepth || 0,
         language
       }, versionStatus, project);
@@ -58,6 +131,238 @@ function* ensureNodeTreeSaga(action) {
   }
 }
 
+const i18nSagas = [takeEvery(actions.INIT_LOCALES.type, getProjectLanguages), takeEvery(actions.UPDATE_LANGUAGE.type, updateLanguage), takeEvery(actions.SET_LANGUAGE.type, setLanguageRoute)];
+
+/**
+ * Resolve the current route language based on the entry, node, static route or path
+ * Is called directly from the routing saga as soon as an entry or node has been fetched
+ */
+function* resolveCurrentRouteLanguage({
+  entry,
+  node
+}) {
+  var _entry$sys, _staticRoute$route;
+  const currentLanguage = yield select(selectCurrentLanguage);
+  const staticRoute = yield select(selectStaticRoute);
+  let nextLanguage = currentLanguage;
+  if (entry !== null && entry !== void 0 && (_entry$sys = entry.sys) !== null && _entry$sys !== void 0 && _entry$sys.language) nextLanguage = entry.sys.language;else if (node !== null && node !== void 0 && node.language) nextLanguage = node.language;else if (staticRoute !== null && staticRoute !== void 0 && (_staticRoute$route = staticRoute.route) !== null && _staticRoute$route !== void 0 && _staticRoute$route.language) nextLanguage = staticRoute.route.language;else {
+    var _currentPath$split$fi;
+    // attempt to infer language from the path
+    const currentPath = yield select(selectCurrentPath);
+
+    // path is normally lowercase
+    const firstPathSegment = (_currentPath$split$fi = currentPath.split('/').find(segment => segment.length)) === null || _currentPath$split$fi === void 0 ? void 0 : _currentPath$split$fi.toLowerCase();
+    const locales = yield select(selectLocales);
+    const matchedLanguage = Object.keys(locales).find(lang => lang.toLowerCase() === firstPathSegment);
+    // matched a supported language in the path
+    if (matchedLanguage) nextLanguage = matchedLanguage;else
+      // falling back to primary language
+      nextLanguage = yield select(selectPrimaryLanguage);
+  }
+  if (nextLanguage && nextLanguage !== currentLanguage) {
+    const dictionary = yield call(resolveDictionaryForLanguage, nextLanguage);
+    yield put(actions.SET_LANGUAGE({
+      language: nextLanguage,
+      dictionary
+    }));
+  }
+}
+
+/**
+ * Resolve the current dictionary for route language either using a supplied resolver
+ * function or directly derive from the locales stored in state
+ * Is called directly any time the language is changed
+ */
+function* resolveDictionaryForLanguage(language) {
+  let dictionary = yield select(selectDictionary);
+  // try and resolve a dictionary for this language
+  const resolver = yield select(selectDictionaryResolver);
+  if (typeof resolver === 'function') {
+    try {
+      // dynamic import of dictionary file
+      const loadedDictionary = yield call(resolver, language);
+      dictionary = loadedDictionary;
+    } catch (error) {
+      console.error(`No dictionary resolved for language ${language}`, error);
+    }
+  } else {
+    // Load dictionary from locales in state
+    const locales = yield select(selectLocales);
+    if (locales && locales[language]) {
+      dictionary = locales[language];
+    }
+  }
+  return dictionary;
+}
+
+/**
+ * Side effects triggered from updating the language via dispatched action
+ * in language switching components, including resolving the next route,
+ * update the dictionary and subsequently redirect if needed
+ */
+function* updateLanguage({
+  payload: {
+    language,
+    redirect,
+    fallbackPath
+  }
+}) {
+  const currentLanguage = yield select(selectCurrentLanguage);
+  if (language === currentLanguage) {
+    // no change needed
+    return;
+  } else {
+    const dictionary = language !== currentLanguage ? yield call(resolveDictionaryForLanguage, language) : yield select(selectDictionary);
+    const uri = yield call(resolveNextLanguageRoute, {
+      language,
+      redirect,
+      fallbackPath
+    });
+    yield put(actions.SET_LANGUAGE({
+      language,
+      dictionary: dictionary != null ? dictionary : undefined,
+      redirect: redirect !== false ? uri : undefined
+    }));
+  }
+}
+
+/** Handle any route redirection after we have set the language */
+function* setLanguageRoute({
+  payload
+}) {
+  if (payload !== null && payload !== void 0 && payload.redirect) {
+    const currentPath = yield select(selectCurrentPath);
+    if (payload.redirect === currentPath) {
+      // already on the correct path, no need to redirect
+      return;
+    }
+    yield put(setRoute(payload.redirect));
+  }
+}
+
+/** Determine the correct route uri when the language changes */
+function* resolveNextLanguageRoute({
+  language,
+  redirect,
+  fallbackPath
+}) {
+  // have they supplied the route to go to?
+  if (typeof redirect === 'string') {
+    return redirect;
+  }
+
+  // is this an entry or a static route?
+  const availableLanguages = yield select(selectRouteEntryAvailableLanguages);
+  if (availableLanguages.find(l => l.toLowerCase() === language.toLowerCase())) {
+    // if entry, get the uri for this language variation from the api
+    const entryUri = yield call(getEntryUriForLanguage, {
+      entryId: yield select(selectRouteEntryID),
+      language
+    });
+    if (entryUri) {
+      return entryUri;
+    }
+  }
+
+  // if static route, get the uri from the routes config
+  const staticRouteUri = yield call(getStaticRouteUri, {
+    language
+  });
+  if (staticRouteUri) {
+    return staticRouteUri;
+  }
+
+  // if all else fails, fallback to the supplied fallback path or homepage
+  return fallbackPath || `/${language.toLowerCase()}`;
+}
+
+/** Check any current static route for a language variation we have stored in i18n.routes */
+function* getStaticRouteUri({
+  language
+}) {
+  const staticRoute = yield select(selectStaticRoute);
+  if (staticRoute !== null && staticRoute !== void 0 && staticRoute.route.path) {
+    var _Object$entries$find;
+    // Routes can have parameters such as `/:facet?` we need to deparameterise
+    // so we can check against our stored locale routes
+    const deparameterisedPath = deparameterise(staticRoute.route.path);
+    const localeRoutes = yield select(selectLocaleRoutes);
+    const originalPath = (_Object$entries$find = Object.entries(localeRoutes || {}).find(([, locales]) => Object.values(locales).includes(deparameterisedPath))) === null || _Object$entries$find === void 0 ? void 0 : _Object$entries$find[0];
+    const routeLocales = localeRoutes[deparameterisedPath] || localeRoutes[originalPath || ''];
+    const routeUri = routeLocales === null || routeLocales === void 0 ? void 0 : routeLocales[language];
+    return routeUri;
+  }
+}
+
+/**
+ * Run when the app initiates locales, populating supported languages from the config
+ * or fetching from the project if not provided
+ */
+function* getProjectLanguages({
+  payload
+}) {
+  const stateLocales = yield select(selectLocales);
+  if (stateLocales && Object.keys(stateLocales).length > 0)
+    // Locales already set in state, no need to fetch again
+    return;
+  const locales = {};
+  let primaryLanguage = payload.primaryLanguage;
+  const supportedLanguages = [...(payload.supportedLanguages || [])];
+  if (supportedLanguages !== null && supportedLanguages !== void 0 && supportedLanguages.length) {
+    // If supported languages are provided in config, use these
+    for (const supportedLanguage of supportedLanguages) {
+      locales[supportedLanguage] = {};
+    }
+  } else {
+    // Fallback to getting languages from the project
+    const [error, project] = yield to(cachedSearch.getClient().project.get());
+    if (error) {
+      console.error('Problem fetching project languages:', error);
+    } else if (project) {
+      var _project$primaryLangu;
+      for (const supportedLanguage of project.supportedLanguages || []) {
+        locales[supportedLanguage] = {};
+        supportedLanguages.push(supportedLanguage);
+      }
+      // Set primary language from project if we have it
+      primaryLanguage = (_project$primaryLangu = project.primaryLanguage) != null ? _project$primaryLangu : primaryLanguage;
+    }
+  }
+  if (Object.keys(locales).length === 0) {
+    // Ensure at least the primary language is included
+    locales[payload.primaryLanguage] = {};
+    supportedLanguages.push(payload.primaryLanguage);
+  }
+
+  // Only commit if we have locales to set or we will end up in an infinite loop
+  if (Object.keys(locales).length) yield put(actions.SET_LOCALES({
+    ...payload,
+    primaryLanguage,
+    supportedLanguages,
+    locales
+  }));
+}
+
+/**
+ * Run a Delivery API query to get the uri for the chosen language variation of this entryId
+ * */
+function* getEntryUriForLanguage({
+  entryId,
+  language
+}) {
+  try {
+    const versionStatus = yield select(selectVersionStatus);
+    const query = new Query(Op.equalTo('sys.id', entryId), Op.equalTo('sys.language', language), Op.equalTo('sys.versionStatus', versionStatus));
+    query.fields = ['sys.uri'];
+    query.pageSize = 1;
+    const result = yield cachedSearch.search(query);
+    return result.items.length ? result.items[0].sys.uri : null;
+  } catch (error) {
+    console.error('Error fetching language variations:', error);
+    yield put(actions.GET_ENTRY_URI_ERROR(error));
+  }
+}
+
 const sys = {
   versionStatus: 'sys.versionStatus'
 };
@@ -80,6 +385,88 @@ const routeEntryByFieldsQuery = (id, language = 'en-GB', contentTypeId = '', fie
   return query;
 };
 
+function* reduxInjectorSaga(injectorFn) {
+  if (typeof injectorFn === 'function') {
+    const {
+      key,
+      reducer,
+      saga
+    } = yield injectorFn();
+    injectRedux({
+      key,
+      reducer,
+      saga
+    });
+  }
+}
+
+/**
+ * @description Asynchronously load and inject assets related to Search
+ */
+const importSearchAssets = () => import('./search.js');
+
+/**
+ * Invokes the Search saga if:
+ * - `searchOptions` is present on `staticRoute` or `contentTypeRoute`
+ * - `searchOptions` is provided by the consumer app
+ *   - and path starts with one of `onPaths: ['/search']`
+ *   - or a `facet` or `listingType` is present in provided `searchOptions`
+ *
+ * A `config` is required if we want to inject the redux reducer here, sagas are injected automatically
+ */
+function* handleSearchSaga({
+  location,
+  params,
+  routeSearchOptions,
+  searchOptions,
+  ssr
+}) {
+  // Merge supplied mappers with route-supplied mappers taking precedence
+  const mappers = {
+    results: e => e,
+    ...((searchOptions === null || searchOptions === void 0 ? void 0 : searchOptions.mappers) || {}),
+    ...((routeSearchOptions === null || routeSearchOptions === void 0 ? void 0 : routeSearchOptions.mappers) || {})
+  };
+
+  // Merge all other search options with route-supplied options taking precedence
+  const {
+    onPaths = ['/search'],
+    ...searchOpts
+  } = {
+    ...(routeSearchOptions || {}),
+    ...(searchOptions || {})
+  };
+
+  // Check do we meet conditions to run the search saga
+  const invokeSearch = onPaths.find(p => location.pathname.startsWith(p)) || searchOpts.composition || searchOpts.facet || searchOpts.listingType;
+
+  // An empty routeSearchOptions object can be used to import assets and load config for a minilist
+  const importAssets = routeSearchOptions;
+  if (importAssets || invokeSearch) {
+    // Async load search assets
+    const {
+      reducer,
+      sagas,
+      setRouteFilters
+    } = yield importSearchAssets();
+
+    // Inject search reducer and sagas
+    yield call(reduxInjectorSaga, async () => ({
+      key: 'search',
+      reducer: searchOpts.config && reducer(searchOpts.config),
+      saga: sagas
+    }));
+    if (invokeSearch) yield call(setRouteFilters, {
+      params,
+      ssr,
+      ...searchOpts,
+      mappers
+    });
+  }
+}
+
+const error = (e, message) => logError(`[routeSaga]${message ? ` ${message}` : ''}`, e);
+let livePreviewTask = null;
 const routingSagas = [takeEvery(SET_NAVIGATION_PATH, getRouteSaga), takeEvery(SET_ROUTE, setRouteSaga)];
 
 /**
@@ -98,7 +485,7 @@ function* setRouteSaga(action) {
 function* getRouteSaga(action) {
   let entry = null;
   try {
-    var _staticRoute$route, _staticRoute$route2, _staticRoute$route3, _staticRoute$route4, _appsays, _appsays2, _appsays3, _pathNode3, _pathNode4;
+    var _staticRoute$route, _staticRoute$route2, _staticRoute$route3, _staticRoute$route4, _appsays, _appsays2, _appsays3, _pathNode3, _pathNode4, _pathNode5;
     const {
       withEvents,
       routes: {
@@ -107,7 +494,8 @@ function* getRouteSaga(action) {
       staticRoute,
       // get api instance from ssr context that is connected to the specific request in ssr
       ssr: {
-        api
+        api,
+        subsitePath
       }
     } = action;
 
@@ -124,7 +512,12 @@ function* getRouteSaga(action) {
     // These variables are the return values from
     // calls to withEvents.onRouteLoad and onRouteLoaded
     let appsays,
-      requireLogin = false;
+      requireLogin = false,
+      searchOptions = false;
+
+    // Route parameters are used for driving search options and live preview functionality,
+    // and are passed to the consuming app via withEvents hooks
+    const params = routeParams(staticRoute, action.location);
     if (withEvents && withEvents.onRouteLoad) {
       appsays = yield withEvents.onRouteLoad(action);
     }
@@ -141,15 +534,30 @@ function* getRouteSaga(action) {
     const entryFieldLinkDepths = (_appsays = appsays) === null || _appsays === void 0 ? void 0 : _appsays.entryFieldLinkDepths;
     const setStaticRouteLimits = typeof linkDepth !== 'undefined' || fields || fieldLinkDepths;
     const setContentTypeLimits = !!ContentTypeMappings.find(ct => ct.fields || ct.linkDepth || ct.nodeOptions || ct.fieldLinkDepths);
+
+    // Limits set in a static route take priority over limits in a content type mapping
+    // If we have limits set in:
+    //   - a matched static route - set them here to resolve everything with the initial node upfront
+    //   - any content type mapping - we set defaults for the initial node resolve then
+    //     - identify the contentTypeId and locate the content type mapping
+    //     - perform a second search query with the limits applied from the content type mapping
+    // If no limits are set in route configuration:
+    //   - fall back to entryLinkDepth and entryFieldLinkDepths provided by the app in `onRouteLoad` event
+    //   - or default to entryLinkDepth of 2 with all fields (default for legacy `/preview` endpoints)
+    fields = setStaticRouteLimits ? fields || '*' : setContentTypeLimits ? ['sys.contentTypeId', 'sys.id'] : '*';
+    linkDepth = setStaticRouteLimits && typeof linkDepth !== 'undefined' ? linkDepth : setContentTypeLimits ? 0 : entryLinkDepth;
+    fieldLinkDepths = setStaticRouteLimits ? fieldLinkDepths : setContentTypeLimits ? undefined : entryFieldLinkDepths;
     const state = yield select();
     const routeEntry = selectRouteEntry(state, 'js');
     const routeNode = selectCurrentNode(state, 'js');
     const currentPath = action.path; //selectCurrentPath(state);
+    const contentPath = action.contentPath;
     const deliveryApiStatus = selectVersionStatus(state);
     const project = selectCurrentProject(state);
     // const isHome = currentPath === '/';
     const isPreview = currentPath && currentPath.startsWith('/preview/');
-    const defaultLang = appsays && appsays.defaultLang || 'en-GB';
+    const currentLanguage = selectCurrentLanguage(state);
+    const defaultLang = appsays && appsays.defaultLang || currentLanguage || 'en-GB';
     if (!isPreview && ((_appsays2 = appsays) !== null && _appsays2 !== void 0 && _appsays2.customRouting || staticRoute && !staticRoute.route.fetchNode || routeEntry && action.statePath === action.path && ((_appsays3 = appsays) === null || _appsays3 === void 0 ? void 0 : _appsays3.refetchNode) !== true)) {
       var _staticRoute$route5;
       // To prevent erroneous 404s and wasted network calls, this covers
@@ -162,21 +570,25 @@ function* getRouteSaga(action) {
           entry: null
         };
         pathNode.entry = entry = routeEntry;
-        //Do nothing, the entry is allready the right one.
-        // yield put({
-        //   type: SET_ENTRY,
-        //   entry,
-        //   node: routeNode,
-        //   isLoading: false,
-        // });
         yield put({
           type: UPDATE_LOADING_STATE,
           isLoading: false
         });
+        if (params.livePreview && typeof window !== 'undefined') {
+          var _contentTypeMapping, _contentTypeMapping2, _contentTypeMapping3;
+          // Update the "limits" (fields, fieldLinkDepths and linkDepth)
+          // used in route resolution (likely SSR) based on the entry's content type mapping
+          // so that we can pass the correct limits to live preview parent
+          contentTypeMapping = findContentTypeMapping(ContentTypeMappings, entry.sys.contentTypeId);
+          // Static route limits override content type mapping limits
+          fields = setStaticRouteLimits ? fields || '*' : ((_contentTypeMapping = contentTypeMapping) === null || _contentTypeMapping === void 0 ? void 0 : _contentTypeMapping.fields) || fields;
+          linkDepth = setStaticRouteLimits ? linkDepth || 0 : typeof ((_contentTypeMapping2 = contentTypeMapping) === null || _contentTypeMapping2 === void 0 ? void 0 : _contentTypeMapping2.linkDepth) !== 'undefined' ? contentTypeMapping.linkDepth : linkDepth;
+          fieldLinkDepths = setStaticRouteLimits ? fieldLinkDepths : ((_contentTypeMapping3 = contentTypeMapping) === null || _contentTypeMapping3 === void 0 ? void 0 : _contentTypeMapping3.fieldLinkDepths) || fieldLinkDepths;
+        }
       } else yield call(setRouteEntry, currentPath, routeEntry, yield select(selectCurrentNode), yield select(selectCurrentAncestors), yield select(selectCurrentSiblings));
     } else {
       var _staticRoute$route6;
-      // Handle preview routes
+      // Handle preview routes (legacy - can we remove?)
       if (isPreview) {
         let splitPath = currentPath.split('/');
         let entryGuid = splitPath[2];
@@ -189,7 +601,6 @@ function* getRouteSaga(action) {
           // for previewing entries as it gives a response of []
           // -- apparently it is not correct to request latest content
           // with Node API
-
           let previewEntry = yield api.getClient(deliveryApiStatus, project).entries.get({
             id: entryGuid,
             language,
@@ -212,11 +623,13 @@ function* getRouteSaga(action) {
         // Resolve the complete entry with the node if we are setting limits in a static route
         [nodeError, pathNode] = yield to(api.getNode({
           depth: 0,
-          path: currentPath,
-          entryFields: setStaticRouteLimits ? fields || '*' : setContentTypeLimits ? ['sys.contentTypeId', 'sys.id'] : '*',
-          entryLinkDepth: setStaticRouteLimits && typeof linkDepth !== 'undefined' ? linkDepth : entryLinkDepth || 0,
-          entryFieldLinkDepths: setStaticRouteLimits ? fieldLinkDepths : setContentTypeLimits ? undefined : entryFieldLinkDepths,
-          language: defaultLang,
+          path: contentPath,
+          entryFields: fields,
+          entryLinkDepth: linkDepth,
+          entryFieldLinkDepths: fieldLinkDepths,
+          // language parameter is not used when resolving a node by path
+          // https://www.contensis.com/help-and-docs/apis/delivery-http/navigation/nodes/get-a-node-by-path
+          // language: defaultLang,
           versionStatus: deliveryApiStatus
         }, project));
         if (nodeError) {
@@ -266,10 +679,10 @@ function* getRouteSaga(action) {
           if (!setStaticRouteLimits) ({
             fieldLinkDepths,
             fields,
-            linkDepth
+            linkDepth = 0
           } = contentTypeMapping || {});
           const query = routeEntryByFieldsQuery(pathNode.entry.sys.id, pathNode.entry.sys.language, pathNode.entry.sys.contentTypeId, fields, fieldLinkDepths, deliveryApiStatus);
-          const payload = yield api.search(query, typeof linkDepth !== 'undefined' ? linkDepth : entryLinkDepth || 0, project);
+          const payload = yield api.search(query, linkDepth, project);
           if ((payload === null || payload === void 0 || (_payload$items = payload.items) === null || _payload$items === void 0 ? void 0 : _payload$items.length) > 0) {
             pathNode.entry = entry = payload.items[0];
           }
@@ -283,25 +696,42 @@ function* getRouteSaga(action) {
         appsays,
         contentTypeMapping: contentTypeMapping || (staticRoute === null || staticRoute === void 0 || (_staticRoute$route6 = staticRoute.route) === null || _staticRoute$route6 === void 0 ? void 0 : _staticRoute$route6.fetchNode) || {},
         language: defaultLang,
-        path: currentPath,
+        path: contentPath,
         pathNode,
         project,
+        subsitePath,
         versionStatus: deliveryApiStatus
       });
       if (children) pathNode.children = children;
     }
-    const resolvedContentTypeMapping = findContentTypeMapping(ContentTypeMappings, (_pathNode3 = pathNode) === null || _pathNode3 === void 0 || (_pathNode3 = _pathNode3.entry) === null || _pathNode3 === void 0 || (_pathNode3 = _pathNode3.sys) === null || _pathNode3 === void 0 ? void 0 : _pathNode3.contentTypeId) || {};
+
+    // We initially listened for SET_ENTRY to complete before
+    // resolving the current route language, but this meant
+    // that the language change was not captured in time for the SSR response
+    yield call(resolveCurrentRouteLanguage, {
+      entry: (_pathNode3 = pathNode) === null || _pathNode3 === void 0 ? void 0 : _pathNode3.entry,
+      node: pathNode
+    });
+    const contentTypeRoute = findContentTypeMapping(ContentTypeMappings, (_pathNode4 = pathNode) === null || _pathNode4 === void 0 || (_pathNode4 = _pathNode4.entry) === null || _pathNode4 === void 0 || (_pathNode4 = _pathNode4.sys) === null || _pathNode4 === void 0 ? void 0 : _pathNode4.contentTypeId);
 
     // Inject redux { key, reducer, saga } provided by ContentTypeMapping
-    if (resolvedContentTypeMapping.injectRedux) yield call(reduxInjectorSaga, resolvedContentTypeMapping.injectRedux);
+    if (contentTypeRoute !== null && contentTypeRoute !== void 0 && contentTypeRoute.injectRedux) yield call(reduxInjectorSaga, contentTypeRoute.injectRedux);
+
+    // Have we defined search options in the route configuration (for triggering search)
+    const routeSearchOptions = getSearchOptions(staticRoute, contentTypeRoute);
     if (withEvents && withEvents.onRouteLoaded) {
       // Check if the app has provided a requireLogin boolean flag or groups array
       // in addition to checking if requireLogin is set in the route definition
+      // The app can provide an object to invoke the search saga
       ({
-        requireLogin
+        requireLogin,
+        searchOptions
       } = (yield withEvents.onRouteLoaded({
         ...action,
-        entry
+        contentTypeRoute,
+        entry,
+        params,
+        searchOptions: routeSearchOptions
       })) || {});
     }
     if (requireLogin !== false) {
@@ -312,22 +742,88 @@ function* getRouteSaga(action) {
         requireLogin
       });
     }
+    if (searchOptions || routeSearchOptions) yield call(handleSearchSaga, {
+      ...action,
+      params,
+      routeSearchOptions,
+      searchOptions
+    });
     if (!appsays || !appsays.preventScrollTop) {
       // Scroll into View
       if (typeof window !== 'undefined') window.scrollTo(0, 0);
     }
-    if ((_pathNode4 = pathNode) !== null && _pathNode4 !== void 0 && (_pathNode4 = _pathNode4.entry) !== null && _pathNode4 !== void 0 && (_pathNode4 = _pathNode4.sys) !== null && _pathNode4 !== void 0 && _pathNode4.id) {
+    if ((_pathNode5 = pathNode) !== null && _pathNode5 !== void 0 && (_pathNode5 = _pathNode5.entry) !== null && _pathNode5 !== void 0 && (_pathNode5 = _pathNode5.sys) !== null && _pathNode5 !== void 0 && _pathNode5.id) {
       var _appsays4;
+      entryMapper = entryMapper || (contentTypeRoute === null || contentTypeRoute === void 0 ? void 0 : contentTypeRoute.entryMapper);
+      if (params.livePreview && typeof window !== 'undefined') {
+        if (livePreviewTask) yield cancel(livePreviewTask);
+        livePreviewTask = yield fork(watchLivePreviewSaga, {
+          currentPath,
+          entry,
+          entryMapper,
+          pathNode,
+          limits: {
+            fields,
+            fieldLinkDepths,
+            linkDepth
+          }
+        });
+      }
       entry = pathNode.entry;
-      yield call(setRouteEntry, currentPath, entry, pathNode, ancestors, siblings, entryMapper || resolvedContentTypeMapping.entryMapper, false, (_appsays4 = appsays) === null || _appsays4 === void 0 ? void 0 : _appsays4.refetchNode);
+      yield call(setRouteEntry, currentPath, entry, pathNode, ancestors, siblings, entryMapper, false, (_appsays4 = appsays) === null || _appsays4 === void 0 ? void 0 : _appsays4.refetchNode);
     } else {
       if (staticRoute) yield call(setRouteEntry, currentPath, null, pathNode, ancestors, siblings);else yield call(do404);
     }
   } catch (e) {
-    log.error(...['Error running route saga:', e, e.stack]);
+    error(e);
     yield call(do500, e);
   }
 }
+function createLivePreviewChannel() {
+  return eventChannel(emit => {
+    const handler = e => {
+      var _e$data;
+      // console.log('Received message in live preview channel', e.data);
+      if ((_e$data = e.data) !== null && _e$data !== void 0 && (_e$data = _e$data.type) !== null && _e$data !== void 0 && _e$data.startsWith('LIVE_ENTRY_')) emit(e.data);
+    };
+    window.addEventListener('message', handler);
+    return () => window.removeEventListener('message', handler);
+  });
+}
+function* watchLivePreviewSaga(context) {
+  var _parent;
+  const channel = createLivePreviewChannel();
+  const routeLoadOptions = {
+    type: 'LIVE_ENTRY_ROUTE_LOAD_OPTIONS',
+    payload: context.limits
+  };
+  if (routeParams().debug) routeLoadOptions.debug = context.pathNode;
+  (_parent = parent) === null || _parent === void 0 || _parent.postMessage(routeLoadOptions, '*');
+  try {
+    while (true) {
+      const data = yield take(channel);
+      let entry = yield select(selectRouteEntry);
+      if (data.type === 'LIVE_ENTRY_RESET') {
+        console.log('Resetting live preview entry to original route entry');
+        entry = context.entry;
+      } else if (data.type === 'LIVE_ENTRY_UPDATE') {
+        console.log('Handling live preview update', data);
+        entry = {
+          ...entry,
+          ...data.payload
+        };
+      }
+      yield call(setRouteEntry, context.currentPath, entry, context.pathNode, null,
+      // ancestors unchanged
+      null,
+      // siblings unchanged
+      context.entryMapper, false, true // we need to remap the entry here
+      );
+    }
+  } finally {
+    if (yield cancelled()) channel.close();
+  }
+}
 function* resolveCurrentNodeOrdinates(action) {
   const {
     api,
@@ -337,6 +833,7 @@ function* resolveCurrentNodeOrdinates(action) {
     path,
     pathNode,
     project,
+    subsitePath,
     versionStatus
   } = action;
   const apiCall = [() => null, () => null, () => null, () => null];
@@ -359,10 +856,11 @@ function* resolveCurrentNodeOrdinates(action) {
           return yield api.getAncestors({
             id: pathNode.id,
             language,
-            versionStatus
+            versionStatus,
+            startLevel: (subsitePath || '').split('/').length
           }, project);
         } catch (ex) {
-          log.info('Problem fetching ancestors', ex);
+          error(ex, 'Problem fetching ancestors');
           return [];
         }
       };
@@ -382,7 +880,7 @@ function* resolveCurrentNodeOrdinates(action) {
             versionStatus
           }, project);
         } catch (ex) {
-          log.info('Problem fetching children', ex);
+          error(ex, 'Problem fetching children');
           return [];
         }
       };
@@ -401,7 +899,7 @@ function* resolveCurrentNodeOrdinates(action) {
             versionStatus
           }, project);
         } catch (ex) {
-          log.info('Problem fetching siblings', ex);
+          error(ex, 'Problem fetching siblings');
           return [];
         }
       };
@@ -465,7 +963,7 @@ function* mapRouteEntry(entryMapper, node) {
       return mappedEntry;
     }
   } catch (e) {
-    log.error(...['Error running entryMapper:', e, e.stack]);
+    error(e, 'Error in entryMapper:');
     throw e;
   }
   return;
@@ -500,20 +998,6 @@ function* do500(error) {
     statusCode: error && error.status ? error.status : 500
   });
 }
-function* reduxInjectorSaga(injectorFn) {
-  if (typeof injectorFn === 'function') {
-    const {
-      key,
-      reducer,
-      saga
-    } = yield injectorFn();
-    injectRedux({
-      key,
-      reducer,
-      saga
-    });
-  }
-}
 
 const registerSagas = [takeEvery(REGISTER_USER, registerSaga), takeEvery(REGISTER_USER_SUCCESS, redirectSaga)];
 function* registerSaga({
@@ -763,11 +1247,6 @@ function* changePasswordSaga(action) {
       });
       return;
     }
-
-    // // eslint-disable-next-line no-console
-    // console.log(changePasswordObject);
-    // // eslint-disable-next-line no-console
-    // console.log(userCredentialsObject);
     yield put({
       type: CHANGE_USER_PASSWORD_SUCCESS
     });
@@ -781,13 +1260,16 @@ function* changePasswordSaga(action) {
 
 const userSagas = [...loginSagas, ...registerSagas, ...resetPasswordSagas];
 
-// index.js
-function rootSaga (featureSagas = []) {
-  return function* rootSaga() {
-    const subSagas = [...routingSagas, ...navigationSagas, ...userSagas];
-    yield all([...subSagas, ...featureSagas]);
-  };
-}
+var rootSaga = (featureSagas = []) => {
+  return [...i18nSagas, ...routingSagas, ...navigationSagas, ...userSagas, ...featureSagas];
+};
+
+// export default function (featureSagas: Effect[] = []) {
+//   return function* rootSaga() {
+//     const subSagas = [...routingSagas, ...navigationSagas, ...userSagas];
+//     yield all([...subSagas, ...featureSagas]);
+//   };
+// }
 
 const servers = SERVERS; /* global SERVERS */
 const alias = servers.alias.toLowerCase();
@@ -832,5 +1314,5 @@ const AppRoot = props => {
   return /*#__PURE__*/React.createElement(RouteLoader, props);
 };
 
-export { AppRoot as A, browserHistory as b, history as h, pickProject as p, rootSaga as r };
-//# sourceMappingURL=App-DLZweVSp.js.map
+export { AppRoot as A, browserHistory as b, createLocaleRoutes as c, history as h, pickProject as p, rootSaga as r, shorten as s };
+//# sourceMappingURL=App-Bplaqueq.js.map