@lowdefy/server 6.1.0 → 7.0.0

package/client/App.jsx

@@ -17,19 +17,21 @@
 import React, { useCallback, useRef } from 'react';
 
 import { ErrorBoundary } from '@lowdefy/block-utils';
-import { useDarkMode, useLocale } from '@lowdefy/client';
+import { IconProvider, useDarkMode, useLocale } from '@lowdefy/client';
 import { StyleProvider } from '@ant-design/cssinjs';
 import { App as AntdApp, theme as antdTheme } from 'antd';
 import { XProvider } from '@ant-design/x';
 
-import { serializer } from '@lowdefy/helpers';
+import { appStorageKey, serializer } from '@lowdefy/helpers';
 
 import antdLocaleLoaders from '../build/i18n/antdLocales.js';
+import appMeta from '../build/appMeta.json';
 import antdXLocaleLoaders from '../build/i18n/antdXLocales.js';
 import dayjsLocaleMap from '../build/i18n/dayjsLocales.js';
 import rawLoggerConfig from '../build/logger.json';
 import Auth from '../lib/client/auth/Auth.jsx';
 import createLogUsage from '../lib/client/createLogUsage.js';
+import getCspNonce from '../lib/client/getCspNonce.js';
 import initSentryClient from '../lib/client/sentry/initSentryClient.js';
 import setSentryUser from '../lib/client/sentry/setSentryUser.js';
 import Page from './Page.jsx';
@@ -37,6 +39,10 @@ import Page from './Page.jsx';
 // Deserialize to restore arrays (e.g. sentry.userFields) from ~arr markers.
 const loggerConfig = serializer.deserialize(rawLoggerConfig);
 
+// antd and antd X put this nonce on the style tags they add, so the page's
+// Content-Security-Policy applies them. Empty (no nonce) when the policy is off.
+const csp = { nonce: getCspNonce() };
+
 function ThemeTokenResolver({ lowdefyRef, children }) {
   const { token } = antdTheme.useToken();
   if (!lowdefyRef.current.theme) {
@@ -47,7 +53,7 @@ function ThemeTokenResolver({ lowdefyRef, children }) {
 }
 
 function App({ config }) {
-  const { rootConfig, session } = config;
+  const { rootConfig, user } = config;
 
   // Sentry DSN arrives at runtime via the embedded config (the server reads
   // SENTRY_DSN per process) — no build-time env inlining.
@@ -57,14 +63,22 @@ function App({ config }) {
   });
 
   const usageDataRef = useRef({});
-  const lowdefyRef = useRef({ eventCallback: createLogUsage({ usageDataRef }) });
+  const lowdefyRef = useRef({
+    // Sent with every request and endpoint call so the server refuses calls
+    // from a tab still running an earlier build (@lowdefy/client request.js).
+    buildId: appMeta.buildId,
+    eventCallback: createLogUsage({ basePath: config.basePath ?? '', usageDataRef }),
+  });
   if (rootConfig?.theme) {
     lowdefyRef.current.theme = rootConfig.theme;
   }
 
+  // Device preferences, kept per app (the same key the HTML template's dark mode script reads).
+  const storageScope = { basePath: config.basePath ?? '', slug: rootConfig.lowdefyApp?.slug };
   const { algorithm, token, components } = useDarkMode({
     antd: lowdefyRef.current.theme?.antd,
     configDarkMode: lowdefyRef.current.theme?.darkMode,
+    storageKey: appStorageKey({ ...storageScope, name: 'lowdefy_darkMode' }),
   });
 
   const {
@@ -76,6 +90,7 @@ function App({ config }) {
     antdLocaleLoaders,
     antdXLocaleLoaders,
     dayjsLocaleMap,
+    storageKey: appStorageKey({ ...storageScope, name: 'lowdefy_locale' }),
   });
 
   if (rootConfig?.i18n?.defaultLocale) {
@@ -108,6 +123,7 @@ function App({ config }) {
   return (
     <StyleProvider layer>
       <XProvider
+        csp={csp}
         locale={mergedLocale}
         form={
           antdLocale?.Form?.defaultValidateMessages
@@ -123,23 +139,27 @@ function App({ config }) {
           algorithm,
         }}
       >
-        <AntdApp>
-          <ThemeTokenResolver lowdefyRef={lowdefyRef}>
-            <ErrorBoundary fullPage onError={handleError}>
-              <Auth session={session}>
-                {(auth) => {
-                  usageDataRef.current.user = auth.session?.hashed_id;
-                  // Set Sentry user context when auth changes
-                  setSentryUser({
-                    user: auth.session,
-                    sentryConfig: loggerConfig.sentry,
-                  });
-                  return <Page auth={auth} config={config} lowdefy={lowdefyRef.current} />;
-                }}
-              </Auth>
-            </ErrorBoundary>
-          </ThemeTokenResolver>
-        </AntdApp>
+        {/* Message, Notification and ConfirmModal render in the App.useApp()
+            holders here, above the Client's icon provider. */}
+        <IconProvider icons={rootConfig.theme.icons}>
+          <AntdApp>
+            <ThemeTokenResolver lowdefyRef={lowdefyRef}>
+              <ErrorBoundary fullPage onError={handleError}>
+                <Auth user={user}>
+                  {(auth) => {
+                    usageDataRef.current.user = auth.user?.id;
+                    // Set Sentry user context when auth changes
+                    setSentryUser({
+                      user: auth.user,
+                      sentryConfig: loggerConfig.sentry,
+                    });
+                    return <Page auth={auth} config={config} lowdefy={lowdefyRef.current} />;
+                  }}
+                </Auth>
+              </ErrorBoundary>
+            </ThemeTokenResolver>
+          </AntdApp>
+        </IconProvider>
       </XProvider>
     </StyleProvider>
   );

package/client/Page.jsx

@@ -14,28 +14,58 @@
   limitations under the License.
 */
 
-import React, { useEffect, useRef, useState } from 'react';
+import React, { useEffect, useReducer, useRef, useState } from 'react';
 
 import Client from '@lowdefy/client';
 import createRouter from '@lowdefy/client/adapters/createRouter.js';
 import createLinkComponent from '@lowdefy/client/adapters/Link.js';
 import { createUrl } from '@lowdefy/client/adapters/url.js';
 import Head from '@lowdefy/client/adapters/Head.js';
+import recordCallerStamp from '@lowdefy/client/recordCallerStamp.js';
+import shouldReloadForBuild from '@lowdefy/client/shouldReloadForBuild.js';
+import shouldReloadForCaller from '@lowdefy/client/shouldReloadForCaller.js';
+import { buildPagePath } from '@lowdefy/helpers';
 
-import actions from '../build/plugins/actions.js';
 import blockMetas from '../build/plugins/blockMetas.json';
-import blocks from '../build/plugins/blocks.js';
-import icons from '../build/plugins/icons.js';
-import operators from '../build/plugins/operators/client.js';
 import jsMap from '../build/plugins/operators/clientJsMap.js';
 import appMeta from '../build/appMeta.json';
 
-import shouldReloadForBuild from './shouldReloadForBuild.js';
+import getShownPage from './getShownPage.js';
+import loadAllIcons from './loadAllIcons.js';
+import loadPageTypes from './loadPageTypes.js';
+import types from './types.js';
+
+// The path to fetch for a navigation. The app root shows the home page, and
+// /api/page/ with an empty path matches no page, so it fetches the home page's
+// own path.
+function getFetchPath({ path, rootConfig }) {
+  if (path !== '') {
+    return path;
+  }
+  const { home, pagePaths } = rootConfig;
+  return buildPagePath({
+    pageId: home.pageId,
+    path: pagePaths[home.pageId],
+    pathParams: home.pathParams,
+  });
+}
 
 // Replaces lib/client/Page.js. The first page renders from the config
-// embedded in the HTML; SPA navigations fetch /api/page/* and swap pageConfig.
+// embedded in the HTML; SPA navigations fetch /api/page/<path> and swap the
+// page. The server matches the path and answers with the page it shows, the
+// values it carries and the path it matched.
 function Page({ auth, config, lowdefy }) {
-  const [pageConfig, setPageConfig] = useState(config.pageConfig);
+  const [page, setPage] = useState({
+    matchedPath: config.matchedPath,
+    pageConfig: config.pageConfig,
+    pathParams: config.pathParams,
+  });
+  // The navigation listener is subscribed once, so it reads the shown page
+  // through a ref rather than the state its closure captured.
+  const pageRef = useRef(page);
+  // A re-render with the same config is how the page context picks up a new
+  // URL (getContext updates a memoized context on every render).
+  const [, rerender] = useReducer((count) => count + 1, 0);
 
   const routerRef = useRef(null);
   if (!routerRef.current) {
@@ -53,26 +83,47 @@ function Page({ auth, config, lowdefy }) {
   const latestNavRef = useRef(0);
 
   useEffect(() => {
-    const unsubscribe = router.subscribe(async ({ pageId }) => {
+    const unsubscribe = router.subscribe(async ({ path, search }) => {
       const token = ++latestNavRef.current;
-      const targetPageId = pageId ?? config.rootConfig.home.pageId;
+      // The path the shown instance was matched on shows the same page and
+      // values whatever the query, so it needs no fetch. Another spelling of
+      // the same values fetches and lands on the same instance. Dynamic pages
+      // re-resolve per navigation.
+      if (path === pageRef.current.matchedPath && pageRef.current.pageConfig.dynamic !== true) {
+        rerender();
+        return;
+      }
+      const fetchPath = getFetchPath({ path, rootConfig: config.rootConfig });
       try {
         // Forward the current query string so server-side Dynamic block
         // resolution sees the same urlQuery as an initial HTML load.
-        const res = await fetch(
-          `${router.basePath}/api/page/${targetPageId}${window.location.search}`
-        );
+        const res = await fetch(`${router.basePath}/api/page/${fetchPath}${search}`);
+        if (res.status === 401 || res.status === 403) {
+          // 401: logged-out navigation to a protected page. 403: authorised but
+          // second factor not yet enrolled. Both carry a { redirect } and full
+          // load away so the destination can return here afterwards.
+          const { redirect } = await res.json();
+          if (token !== latestNavRef.current) return;
+          window.location.assign(
+            redirect ?? createUrl({ basePath: router.basePath, pathname: '/404' })
+          );
+          return;
+        }
         if (!res.ok) {
           if (token !== latestNavRef.current) return;
-          if (targetPageId !== '404') {
+          if (path !== '404') {
             router.replace({ pathname: '/404' });
           }
           return;
         }
-        const { buildId, pageConfig: nextPageConfig } = await res.json();
+        const response = await res.json();
         if (token !== latestNavRef.current) return;
         if (
-          shouldReloadForBuild({ bundleBuildId: appMeta.buildId, serverBuildId: buildId, window })
+          shouldReloadForBuild({
+            bundleBuildId: appMeta.buildId,
+            serverBuildId: response.buildId,
+            window,
+          })
         ) {
           // The app was redeployed after this bundle loaded, so the config may
           // reference _js functions and plugins this bundle does not carry.
@@ -81,15 +132,28 @@ function Page({ auth, config, lowdefy }) {
           window.location.reload();
           return;
         }
-        setPageConfig(nextPageConfig);
+        // The server answered as another caller than this page renders (a
+        // sign-in or organization switch in another tab), or with other roles:
+        // reload so the page renders the server's caller instead of mixing the
+        // two. A second difference within the reload interval throws to the
+        // catch below, whose full page load also renders the server's caller.
+        const serverCaller = res.headers.get('x-lowdefy-caller');
+        if (shouldReloadForCaller({ serverCaller, user: lowdefy.user, window })) {
+          window.location.reload();
+          return;
+        }
+        recordCallerStamp({ lowdefy, serverCaller });
+        // A failed chunk load falls to the catch below: a full page load.
+        await loadPageTypes({ pageConfig: response.pageConfig });
+        if (token !== latestNavRef.current) return;
+        const nextPage = getShownPage({ path, response });
+        pageRef.current = nextPage;
+        setPage(nextPage);
       } catch (error) {
         // Network failure on SPA navigation — fall back to a full page load.
         if (token !== latestNavRef.current) return;
         window.location.assign(
-          createUrl({
-            basePath: router.basePath,
-            pathname: targetPageId === config.rootConfig.home.pageId ? '/' : `/${targetPageId}`,
-          })
+          createUrl({ basePath: router.basePath, pathname: `/${path}`, query: search.slice(1) })
         );
       }
     });
@@ -101,18 +165,18 @@ function Page({ auth, config, lowdefy }) {
       auth={auth}
       Components={{ Head, Link }}
       config={{
-        pageConfig,
+        pageConfig: page.pageConfig,
         rootConfig: config.rootConfig,
       }}
       jsMap={jsMap}
+      loadAllIcons={loadAllIcons}
       lowdefy={lowdefy}
+      matchedPath={page.matchedPath}
+      pathParams={page.pathParams}
       router={router}
       types={{
-        actions,
+        ...types,
         blockMetas,
-        blocks,
-        icons,
-        operators,
       }}
       window={window}
     />

package/client/clearReloadedForTypes.js

@@ -0,0 +1,29 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import RELOADED_FOR_TYPES_KEY from './reloadedForTypesKey.js';
+
+// The first page's types loaded, so a reload this tab made for them worked. A
+// later failure at the same URL (a deploy since) may reload once again.
+function clearReloadedForTypes({ window }) {
+  try {
+    window.sessionStorage.removeItem(RELOADED_FOR_TYPES_KEY);
+  } catch (error) {
+    // Storage disabled: nothing was recorded.
+  }
+}
+
+export default clearReloadedForTypes;

package/client/clientBuildImports.test.mjs

@@ -30,12 +30,10 @@ const allowed = new Set([
   'i18n/antdLocales.js',
   'i18n/antdXLocales.js',
   'i18n/dayjsLocales.js',
-  'plugins/actions.js',
   'plugins/blockMetas.json',
-  'plugins/blocks.js',
-  'plugins/icons.js',
-  'plugins/operators/client.js',
   'plugins/operators/clientJsMap.js',
+  // Type-set hashes and chunk loaders only - never page ids or config.
+  'plugins/pageTypes.js',
 ]);
 
 const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -51,9 +49,10 @@ function listSourceFiles(dir) {
 test('client code imports only client-safe build artifacts', () => {
   const imported = ['client', 'lib/client'].flatMap((dir) =>
     listSourceFiles(path.join(root, dir)).flatMap((file) =>
-      [...fs.readFileSync(file, 'utf8').matchAll(/from '[^']*\/build\/([^']+)'/g)].map(
-        (match) => ({ file: path.relative(root, file), artifact: match[1] })
-      )
+      [...fs.readFileSync(file, 'utf8').matchAll(/from '[^']*\/build\/([^']+)'/g)].map((match) => ({
+        file: path.relative(root, file),
+        artifact: match[1],
+      }))
     )
   );
   expect(imported.length).toBeGreaterThan(0);

package/client/getShownPage.js

@@ -0,0 +1,28 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// The page a navigation to `path` shows, from the page response. At the app root the client
+// fetches the home page's own path, but the shown instance is matched on the root, as on a first
+// load there, so a later navigation to the root (a query change, the home link) needs no fetch.
+function getShownPage({ path, response }) {
+  const { pageConfig, pathParams } = response;
+  if (path === '') {
+    return { matchedPath: '', pageConfig, pathParams };
+  }
+  return { matchedPath: response.matchedPath, pageConfig, pathParams };
+}
+
+export default getShownPage;

package/client/getShownPage.test.mjs

@@ -0,0 +1,52 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import getShownPage from './getShownPage.js';
+
+const pageConfig = { pageId: 'ticket', path: 'tickets/{space}/{ticket_id}' };
+
+test('getShownPage keeps the path the server matched', () => {
+  expect(
+    getShownPage({
+      path: 'tickets/a%2Bb/1',
+      response: {
+        pageId: 'ticket',
+        pathParams: { space: 'a+b', ticket_id: '1' },
+        matchedPath: 'tickets/a%2Bb/1',
+        pageConfig,
+      },
+    })
+  ).toEqual({
+    matchedPath: 'tickets/a%2Bb/1',
+    pageConfig,
+    pathParams: { space: 'a+b', ticket_id: '1' },
+  });
+});
+
+test('getShownPage matches the home page fetched for the app root on the root', () => {
+  const homeConfig = { pageId: 'users', path: 'admin/users' };
+  expect(
+    getShownPage({
+      path: '',
+      response: {
+        pageId: 'users',
+        pathParams: {},
+        matchedPath: 'admin/users',
+        pageConfig: homeConfig,
+      },
+    })
+  ).toEqual({ matchedPath: '', pageConfig: homeConfig, pathParams: {} });
+});

package/client/loadAllIcons.js

@@ -0,0 +1,45 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { icons } from '../build/plugins/pageTypes.js';
+
+import types from './types.js';
+
+let loading = null;
+
+// Each page loads the icons its config names. A name that only arrives at
+// runtime - from state, a request, HTML built from data, theme.icons.include -
+// may be outside that set, so the first icon that misses loads every icon the
+// app bundles, once per tab. Every caller shares the one load; a failed load
+// is logged here and cleared, so the next miss tries again.
+function loadAllIcons() {
+  if (loading === null) {
+    loading = icons().then(
+      (module) => {
+        Object.assign(types.icons, module.default);
+      },
+      (error) => {
+        loading = null;
+        // eslint-disable-next-line no-console
+        console.error(error);
+        throw error;
+      }
+    );
+  }
+  return loading;
+}
+
+export default loadAllIcons;

package/client/loadPageTypes.js

@@ -0,0 +1,44 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import pageTypes, { allTypes } from '../build/plugins/pageTypes.js';
+
+import loadAllIcons from './loadAllIcons.js';
+import types from './types.js';
+
+// Loads the plugin code one page uses: its type set with its icons (a chunk
+// shared by every page with the same set), and the full type set when Dynamic
+// content reaches outside the page's own types. Dynamic content that names an
+// icon outside the page's set, or types outside it (whose blocks draw their
+// own icons), loads every icon before the first render.
+async function loadPageTypes({ pageConfig }) {
+  const loaders = [pageTypes[pageConfig.typesKey]().then((module) => module.default)];
+  if (pageConfig.loadAllTypes === true) {
+    loaders.push(allTypes());
+  }
+  if (pageConfig.loadAllTypes === true || pageConfig.loadAllIcons === true) {
+    // loadAllIcons merges into types.icons itself, so it adds no type set here.
+    loaders.push(loadAllIcons().then(() => ({})));
+  }
+  const loaded = await Promise.all(loaders);
+  loaded.forEach((typeSet) => {
+    Object.entries(typeSet).forEach(([category, entries]) => {
+      Object.assign(types[category], entries);
+    });
+  });
+}
+
+export default loadPageTypes;

package/client/main.jsx

@@ -23,6 +23,9 @@ import React from 'react';
 import { createRoot } from 'react-dom/client';
 
 import App from './App.jsx';
+import clearReloadedForTypes from './clearReloadedForTypes.js';
+import loadPageTypes from './loadPageTypes.js';
+import shouldReloadForTypes from './shouldReloadForTypes.js';
 
 import '../build/globals.css';
 
@@ -36,4 +39,22 @@ if (import.meta.hot) {
   import.meta.hot.data.root = root;
 }
 
-root.render(<App config={config} />);
+// The first page renders once its plugin code has loaded. The HTML preloads
+// those chunks, so this await overlaps the main bundle's own download.
+async function render() {
+  try {
+    await loadPageTypes({ pageConfig: config.pageConfig });
+    clearReloadedForTypes({ window });
+  } catch (error) {
+    if (shouldReloadForTypes({ window })) {
+      window.location.reload();
+      return;
+    }
+    // Render anyway: missing blocks surface through the full-page ErrorBoundary.
+    // eslint-disable-next-line no-console
+    console.error(error);
+  }
+  root.render(<App config={config} />);
+}
+
+render();

package/client/reloadedForTypesKey.js

@@ -0,0 +1,21 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// sessionStorage key holding the URL this tab last reloaded after the first
+// page's types failed to load.
+const RELOADED_FOR_TYPES_KEY = 'lowdefy.reloadedForTypes';
+
+export default RELOADED_FOR_TYPES_KEY;

package/client/shouldReloadForTypes.js

@@ -0,0 +1,38 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import RELOADED_FOR_TYPES_KEY from './reloadedForTypesKey.js';
+
+// True the first time the first page's type chunks fail to load at a URL — a
+// network blip, or HTML served from an older deploy whose chunks are gone — so
+// the tab reloads once. A second failure at the same URL renders instead of
+// looping, and clears the record so a later visit may retry, as does a load
+// that succeeds (clearReloadedForTypes).
+function shouldReloadForTypes({ window }) {
+  try {
+    if (window.sessionStorage.getItem(RELOADED_FOR_TYPES_KEY) === window.location.href) {
+      window.sessionStorage.removeItem(RELOADED_FOR_TYPES_KEY);
+      return false;
+    }
+    window.sessionStorage.setItem(RELOADED_FOR_TYPES_KEY, window.location.href);
+  } catch (error) {
+    // Storage disabled: without the record the loop guard cannot work.
+    return false;
+  }
+  return true;
+}
+
+export default shouldReloadForTypes;