@shopify/hydrogen 0.0.0-experimental-20220526194818

package/dist/esnext/foundation/Analytics/ClientAnalytics.js

@@ -0,0 +1,97 @@
+import { getNamedspacedEventname } from './utils';
+import { isServer } from '../../utilities';
+import { eventNames } from './const';
+import { EVENT_PATHNAME } from '../../constants';
+const subscribers = {};
+let pageAnalyticsData = {};
+const guardDupEvents = {};
+const USAGE_ERROR = 'ClientAnalytics should only be used within the useEffect callback or event handlers';
+function isInvokedFromServer() {
+    if (isServer()) {
+        console.warn(USAGE_ERROR);
+        return true;
+    }
+    return false;
+}
+function pushToPageAnalyticsData(data, namespace) {
+    if (isInvokedFromServer())
+        return;
+    if (namespace) {
+        pageAnalyticsData[namespace] = Object.assign({}, pageAnalyticsData[namespace] || {}, data);
+    }
+    else {
+        pageAnalyticsData = Object.assign({}, pageAnalyticsData, data);
+    }
+}
+function getPageAnalyticsData() {
+    if (isInvokedFromServer())
+        return;
+    return pageAnalyticsData;
+}
+function resetPageAnalyticsData() {
+    if (isInvokedFromServer())
+        return;
+    pageAnalyticsData = {};
+}
+function publish(eventname, guardDup = false, payload) {
+    if (isInvokedFromServer())
+        return;
+    const namedspacedEventname = getNamedspacedEventname(eventname);
+    const subs = subscribers[namedspacedEventname];
+    const combinedPayload = Object.assign({}, pageAnalyticsData, payload);
+    // De-dup events due to re-renders
+    if (guardDup) {
+        const eventGuardTimeout = guardDupEvents[namedspacedEventname];
+        if (eventGuardTimeout) {
+            clearTimeout(eventGuardTimeout);
+        }
+        const namespacedTimeout = setTimeout(() => {
+            publishEvent(subs, combinedPayload);
+        }, 100);
+        guardDupEvents[namedspacedEventname] = namespacedTimeout;
+    }
+    else {
+        publishEvent(subs, combinedPayload);
+    }
+}
+function publishEvent(subs, payload) {
+    if (subs) {
+        Object.keys(subs).forEach((key) => {
+            subs[key](payload);
+        });
+    }
+}
+function subscribe(eventname, callbackFunction) {
+    if (isInvokedFromServer())
+        return { unsubscribe: () => { } };
+    const namedspacedEventname = getNamedspacedEventname(eventname);
+    const subs = subscribers[namedspacedEventname];
+    if (!subs) {
+        subscribers[namedspacedEventname] = {};
+    }
+    const subscriberId = Date.now().toString();
+    subscribers[namedspacedEventname][subscriberId] = callbackFunction;
+    return {
+        unsubscribe: () => {
+            delete subscribers[namedspacedEventname][subscriberId];
+        },
+    };
+}
+function pushToServer(init, searchParam) {
+    return fetch(`${EVENT_PATHNAME}${searchParam ? `?${searchParam}` : ''}`, Object.assign({
+        method: 'post',
+        headers: {
+            'cache-control': 'no-cache',
+            'Content-Type': 'application/json',
+        },
+    }, init));
+}
+export const ClientAnalytics = {
+    pushToPageAnalyticsData,
+    getPageAnalyticsData,
+    resetPageAnalyticsData,
+    publish,
+    subscribe,
+    pushToServer,
+    eventNames,
+};

package/dist/esnext/foundation/Analytics/ServerAnalyticsRoute.server.d.ts

@@ -0,0 +1,2 @@
+import type { ServerAnalyticsConnector } from '../../types';
+export declare function ServerAnalyticsRoute(request: Request, serverAnalyticsConnectors?: Array<ServerAnalyticsConnector>): Response;

package/dist/esnext/foundation/Analytics/ServerAnalyticsRoute.server.js

@@ -0,0 +1,33 @@
+import { log } from '../../utilities/log';
+export function ServerAnalyticsRoute(request, serverAnalyticsConnectors) {
+    if (request.headers.get('Content-Length') === '0') {
+        serverAnalyticsConnectors === null || serverAnalyticsConnectors === void 0 ? void 0 : serverAnalyticsConnectors.forEach((connector) => {
+            connector.request(request);
+        });
+    }
+    else if (request.headers.get('Content-Type') === 'application/json') {
+        Promise.resolve(request.json())
+            .then((data) => {
+            serverAnalyticsConnectors === null || serverAnalyticsConnectors === void 0 ? void 0 : serverAnalyticsConnectors.forEach((connector) => {
+                connector.request(request, data, 'json');
+            });
+        })
+            .catch((error) => {
+            log.warn('Fail to resolve server analytics: ', error);
+        });
+    }
+    else {
+        Promise.resolve(request.text())
+            .then((data) => {
+            serverAnalyticsConnectors === null || serverAnalyticsConnectors === void 0 ? void 0 : serverAnalyticsConnectors.forEach((connector) => {
+                connector.request(request, data, 'text');
+            });
+        })
+            .catch((error) => {
+            log.warn('Fail to resolve server analytics: ', error);
+        });
+    }
+    return new Response(null, {
+        status: 200,
+    });
+}

package/dist/esnext/foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetrics.client.d.ts

@@ -0,0 +1,7 @@
+declare global {
+    interface Window {
+        BOOMR: any;
+        BOOMR_onload: any;
+    }
+}
+export declare function PerformanceMetrics(): null;

package/dist/esnext/foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetrics.client.js

@@ -0,0 +1,64 @@
+import { useEffect } from 'react';
+import { loadScript } from '../../../../utilities';
+import { ClientAnalytics } from '../../index';
+import { useShop } from '../../../useShop';
+const URL = 'https://cdn.shopify.com/shopifycloud/boomerang/shopify-boomerang-hydrogen.min.js';
+export function PerformanceMetrics() {
+    const { storeDomain } = useShop();
+    useEffect(() => {
+        try {
+            (function () {
+                if (window.BOOMR &&
+                    (window.BOOMR.version || window.BOOMR.snippetExecuted)) {
+                    return;
+                }
+                // Executes only on first mount
+                window.BOOMR = window.BOOMR || {};
+                window.BOOMR.hydrogenPerformanceEvent = (data) => {
+                    ClientAnalytics.publish(ClientAnalytics.eventNames.PERFORMANCE, true, data);
+                    ClientAnalytics.pushToServer({
+                        body: JSON.stringify(data),
+                    }, ClientAnalytics.eventNames.PERFORMANCE);
+                };
+                window.BOOMR.storeDomain = storeDomain;
+                function boomerangSaveLoadTime(e) {
+                    window.BOOMR_onload = (e && e.timeStamp) || Date.now();
+                }
+                // @ts-ignore
+                function boomerangInit(e) {
+                    e.detail.BOOMR.init();
+                    e.detail.BOOMR.t_end = Date.now();
+                }
+                if (window.addEventListener) {
+                    window.addEventListener('load', boomerangSaveLoadTime, false);
+                    // @ts-ignore
+                }
+                else if (window.attachEvent) {
+                    // @ts-ignore
+                    window.attachEvent('onload', boomerangSaveLoadTime);
+                }
+                if (document.addEventListener) {
+                    document.addEventListener('onBoomerangLoaded', boomerangInit);
+                    // @ts-ignore
+                }
+                else if (document.attachEvent) {
+                    // @ts-ignore
+                    document.attachEvent('onpropertychange', function (e) {
+                        if (!e)
+                            e = event;
+                        if (e.propertyName === 'onBoomerangLoaded')
+                            boomerangInit(e);
+                    });
+                }
+            })();
+            loadScript(URL).catch(() => {
+                // ignore if boomerang doesn't load
+                // most likely because of an ad blocker
+            });
+        }
+        catch (err) {
+            // Do nothing
+        }
+    }, [storeDomain]);
+    return null;
+}

package/dist/esnext/foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetrics.server.d.ts

@@ -0,0 +1 @@
+export declare function request(request: Request, data?: any, contentType?: string): void;

package/dist/esnext/foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetrics.server.js

@@ -0,0 +1,24 @@
+export function request(request, data, contentType) {
+    const url = new URL(request.url);
+    if (url.search === '?performance' && contentType === 'json') {
+        const initTime = new Date().getTime();
+        fetch('https://monorail-edge.shopifysvc.com/v1/produce', {
+            method: 'post',
+            headers: {
+                'content-type': 'text/plain',
+                'x-forwarded-for': request.headers.get('x-forwarded-for') || '',
+                'user-agent': request.headers.get('user-agent') || '',
+            },
+            body: JSON.stringify({
+                schema_id: 'hydrogen_buyer_performance/2.0',
+                payload: data,
+                metadata: {
+                    event_created_at_ms: initTime,
+                    event_sent_at_ms: new Date().getTime(),
+                },
+            }),
+        }).catch((error) => {
+            // send to bugsnag? oxygen?
+        });
+    }
+}

package/dist/esnext/foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetricsDebug.client.d.ts

@@ -0,0 +1 @@
+export declare function PerformanceMetricsDebug(): null;

package/dist/esnext/foundation/Analytics/connectors/PerformanceMetrics/PerformanceMetricsDebug.client.js

@@ -0,0 +1,23 @@
+import { useEffect } from 'react';
+import { ClientAnalytics } from '../../index';
+const PAD = 10;
+let isInit = false;
+export function PerformanceMetricsDebug() {
+    useEffect(() => {
+        if (!isInit) {
+            isInit = true;
+            ClientAnalytics.subscribe(ClientAnalytics.eventNames.PERFORMANCE, (data) => {
+                console.group(`Performance - ${data.page_load_type} load`);
+                logMetricIf('TTFB:', data.response_start - data.navigation_start);
+                logMetricIf('FCP:', data.first_contentful_paint);
+                logMetricIf('LCP:', data.largest_contentful_paint);
+                logMetricIf('Duration:', data.response_end - data.navigation_start);
+                console.groupEnd();
+            });
+        }
+    });
+    return null;
+}
+function logMetricIf(lable, data) {
+    data && console.log(`${lable.padEnd(PAD)}${Math.round(data)} ms`);
+}

package/dist/esnext/foundation/Analytics/const.d.ts

@@ -0,0 +1,9 @@
+export declare const eventNames: {
+    PAGE_VIEW: string;
+    VIEWED_PRODUCT: string;
+    ADD_TO_CART: string;
+    REMOVE_FROM_CART: string;
+    UPDATE_CART: string;
+    DISCOUNT_CODE_UPDATED: string;
+    PERFORMANCE: string;
+};

package/dist/esnext/foundation/Analytics/const.js

@@ -0,0 +1,9 @@
+export const eventNames = {
+    PAGE_VIEW: 'page-view',
+    VIEWED_PRODUCT: 'viewed-product',
+    ADD_TO_CART: 'add-to-cart',
+    REMOVE_FROM_CART: 'remove-from-cart',
+    UPDATE_CART: 'update-cart',
+    DISCOUNT_CODE_UPDATED: 'discount-code-updated',
+    PERFORMANCE: 'performance',
+};

package/dist/esnext/foundation/Analytics/hook.d.ts

@@ -0,0 +1 @@
+export declare function useServerAnalytics(data?: any): any;

package/dist/esnext/foundation/Analytics/hook.js

@@ -0,0 +1,7 @@
+import { useServerRequest } from '../ServerRequestProvider';
+export function useServerAnalytics(data) {
+    const request = useServerRequest();
+    if (data)
+        request.ctx.analyticsData = Object.assign({}, request.ctx.analyticsData, data);
+    return request.ctx.analyticsData;
+}

package/dist/esnext/foundation/Analytics/index.d.ts

@@ -0,0 +1,2 @@
+export { useServerAnalytics } from './hook';
+export { ClientAnalytics } from './ClientAnalytics';

package/dist/esnext/foundation/Analytics/index.js

@@ -0,0 +1,2 @@
+export { useServerAnalytics } from './hook';
+export { ClientAnalytics } from './ClientAnalytics';

package/dist/esnext/foundation/Analytics/types.d.ts

@@ -0,0 +1,5 @@
+export declare type Subscriber = {
+    unsubscribe: () => void;
+};
+export declare type SubscriberFunction = (payload: any) => void;
+export declare type Subscribers = Record<string, Record<string, SubscriberFunction>>;

package/dist/esnext/foundation/Analytics/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esnext/foundation/Analytics/utils.d.ts

@@ -0,0 +1 @@
+export declare function getNamedspacedEventname(eventname: string): string;

package/dist/esnext/foundation/Analytics/utils.js

@@ -0,0 +1,8 @@
+import { eventNames } from './const';
+const RESERVED_EVENT_NAMES = Object.values(eventNames);
+export function getNamedspacedEventname(eventname) {
+    // Any event name that is not in the reserved space will be prefix with `c-`
+    return RESERVED_EVENT_NAMES.indexOf(eventname) === -1
+        ? `c-${eventname}`
+        : eventname;
+}

package/dist/esnext/foundation/AnalyticsErrorBoundary.client.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+export default function AnalyticsErrorBoundary({ children, }: {
+    children: ReactNode;
+}): JSX.Element;

package/dist/esnext/foundation/AnalyticsErrorBoundary.client.js

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ErrorBoundary } from 'react-error-boundary';
+export default function AnalyticsErrorBoundary({ children, }) {
+    // Analytics fail to load, most likely due to an ad blocker
+    return (React.createElement(ErrorBoundary, { fallbackRender: () => {
+            return null;
+        } }, children));
+}

package/dist/esnext/foundation/Cookie/Cookie.d.ts

@@ -0,0 +1,48 @@
+export declare type CookieOptions = {
+    /** Whether to secure the cookie so that the browser only sends it over HTTPS. Some
+     * browsers [don't work with secure cookies on localhost](https://owasp.org/www-community/controls/SecureCookieAttribute).
+     */
+    httpOnly?: boolean;
+    /** Whether to secure the cookie so that [client JavaScript is unable to read it](https://owasp.org/www-community/HttpOnly).
+     */
+    secure?: boolean;
+    /** Declares that the cookie should be restricted to a first-party
+     * or [same-site](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite) context.
+     */
+    sameSite?: 'Lax' | 'Strict' | 'None';
+    /** Tells the browser that the cookie should only be sent to the server if it's
+     * within the [defined path](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#path_attribute).
+     */
+    path?: string;
+    /** [A date on which the cookie will expire](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#define_the_lifetime_of_a_cookie).
+     * If the date is in the past, then the browser will remove the cookie.
+     */
+    expires?: Date;
+    /** Secures the cookie so that it's only used on [specific domains](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies#domain_attribute).
+     */
+    domain?: string;
+    /** The [number of seconds until the cookie expires](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#max-agenumber).
+     * `maxAge` takes precedence over `expires` if both are defined.
+     */
+    maxAge?: number;
+};
+/** The `Cookie` component helps you build your own custom cookie and session implementations. All
+ * [Hydrogen session storage mechanisms](https://shopify.dev/custom-storefronts/hydrogen/framework/sessions#types-of-session-storage) use the
+ * same configuration options as what's available in `Cookie`.
+ */
+export declare class Cookie {
+    /** The name of the cookie stored in the browser. */
+    name: string;
+    /** An optional object to configure [how the cookie is persisted in the browser](https://shopify.dev/api/hydrogen/components/framework/cookie#cookie-options). */
+    options?: CookieOptions;
+    data: Record<string, any>;
+    constructor(name: string, options?: CookieOptions);
+    parse(cookie: string): Record<string, any>;
+    set(key: string, value: string): void;
+    setAll(data: Record<string, string>): void;
+    serialize(): string;
+    destroy(): string;
+    get expires(): number;
+    setSessionid(sid: string): void;
+    getSessionId(request: Request): string | null;
+}

package/dist/esnext/foundation/Cookie/Cookie.js

@@ -0,0 +1,67 @@
+import { parse, stringify as stringifyCookie } from 'worktop/cookie';
+import { log } from '../../utilities/log';
+import { parseJSON } from '../../utilities/parse';
+const reservedCookieNames = ['mac', 'user_session_id'];
+/** The `Cookie` component helps you build your own custom cookie and session implementations. All
+ * [Hydrogen session storage mechanisms](https://shopify.dev/custom-storefronts/hydrogen/framework/sessions#types-of-session-storage) use the
+ * same configuration options as what's available in `Cookie`.
+ */
+export class Cookie {
+    constructor(name, options = {}) {
+        if (reservedCookieNames.includes(name)) {
+            log.warn(`Warning "${name}" is a reserved cookie name by oxygen!`);
+        }
+        this.options = options;
+        this.options = {
+            ...this.options,
+            expires: 
+            // maxAge takes precedence
+            typeof options.maxAge !== 'undefined'
+                ? new Date(Date.now() + options.maxAge * 1000)
+                : options.expires
+                    ? options.expires
+                    : new Date(Date.now() + 604800000), // default one week
+        };
+        this.name = name;
+        this.data = {};
+    }
+    parse(cookie) {
+        try {
+            const data = parseJSON(parse(cookie)[this.name]);
+            this.data = data;
+        }
+        catch (e) {
+            // failure to parse cookie
+        }
+        return this.data;
+    }
+    set(key, value) {
+        this.data[key] = value;
+    }
+    setAll(data) {
+        this.data = data;
+    }
+    serialize() {
+        return stringifyCookie(this.name, JSON.stringify(this.data), this.options);
+    }
+    destroy() {
+        this.data = {};
+        return stringifyCookie(this.name, '', {
+            ...this.options,
+            expires: new Date(0),
+        });
+    }
+    get expires() {
+        return this.options.expires.getTime();
+    }
+    setSessionid(sid) {
+        return this.set('sid', sid);
+    }
+    getSessionId(request) {
+        const cookieValue = request.headers.get('cookie');
+        if (cookieValue) {
+            return this.parse(cookieValue).sid;
+        }
+        return null;
+    }
+}

package/dist/esnext/foundation/CookieSessionStorage/CookieSessionStorage.d.ts

@@ -0,0 +1,5 @@
+import type { SessionStorageAdapter } from '../session/session';
+import type { CookieOptions } from '../Cookie/Cookie';
+/** The `CookieSessionStorage` component is the default session storage mechanism for Hydrogen.
+ */
+export declare const CookieSessionStorage: (name: string, options: CookieOptions) => () => SessionStorageAdapter;

package/dist/esnext/foundation/CookieSessionStorage/CookieSessionStorage.js

@@ -0,0 +1,31 @@
+import { Cookie } from '../Cookie/Cookie';
+/** The `CookieSessionStorage` component is the default session storage mechanism for Hydrogen.
+ */
+export const CookieSessionStorage = function (
+/** The name of the cookie stored in the browser. */
+name, 
+/** An optional object to configure [how the cookie is persisted in the browser](https://shopify.dev/api/hydrogen/components/framework/cookie#cookie-options). */
+options) {
+    return function () {
+        const cookie = new Cookie(name, options);
+        let parsed = false;
+        return {
+            async get(request) {
+                if (!parsed) {
+                    const cookieValue = request.headers.get('cookie');
+                    cookie.parse(cookieValue || '');
+                    parsed = true;
+                }
+                return cookie.data;
+            },
+            async set(request, value) {
+                cookie.setAll(value);
+                return cookie.serialize();
+            },
+            async destroy(request) {
+                // @todo - set expires for Date in past
+                return cookie.destroy();
+            },
+        };
+    };
+};

package/dist/esnext/foundation/FileRoutes/FileRoutes.server.d.ts

@@ -0,0 +1,22 @@
+import type { ImportGlobEagerOutput } from '../../types';
+interface FileRoutesProps {
+    /** The routes defined by Vite's [import.meta.globEager](https://vitejs.dev/guide/features.html#glob-import) method. */
+    routes?: ImportGlobEagerOutput;
+    /** A path that's prepended to all file routes. You can modify `basePath` if you want to prefix all file routes. For example, you can prefix all file routes with a locale. */
+    basePath?: string;
+    /** The portion of the file route path that shouldn't be a part of the URL. You need to modify this if you want to import routes from a location other than the default `src/routes`. */
+    dirPrefix?: string | RegExp;
+}
+/**
+ * The `FileRoutes` component builds a set of default Hydrogen routes based on the output provided by Vite's
+ * [import.meta.globEager](https://vitejs.dev/guide/features.html#glob-import) method. You can have multiple
+ * instances of this component to source file routes from multiple locations.
+ */
+export declare function FileRoutes({ routes, basePath, dirPrefix }: FileRoutesProps): JSX.Element | null;
+interface HydrogenRoute {
+    component: any;
+    path: string;
+    exact: boolean;
+}
+export declare function createPageRoutes(pages: ImportGlobEagerOutput, topLevelPath?: string, dirPrefix?: string | RegExp): HydrogenRoute[];
+export {};

package/dist/esnext/foundation/FileRoutes/FileRoutes.server.js

@@ -0,0 +1,74 @@
+import React, { useMemo } from 'react';
+import { matchPath } from '../../utilities/matchPath';
+import { log } from '../../utilities/log';
+import { extractPathFromRoutesKey } from '../../utilities/apiRoutes';
+import { useServerRequest } from '../ServerRequestProvider';
+import { RouteParamsProvider } from '../useRouteParams/RouteParamsProvider.client';
+import { findRoutePrefix } from '../../utilities/findRoutePrefix';
+/**
+ * The `FileRoutes` component builds a set of default Hydrogen routes based on the output provided by Vite's
+ * [import.meta.globEager](https://vitejs.dev/guide/features.html#glob-import) method. You can have multiple
+ * instances of this component to source file routes from multiple locations.
+ */
+export function FileRoutes({ routes, basePath, dirPrefix }) {
+    var _a;
+    const request = useServerRequest();
+    const { routeRendered, serverProps } = request.ctx.router;
+    if (routeRendered)
+        return null;
+    if (!routes) {
+        const fileRoutes = request.ctx.hydrogenConfig.routes;
+        routes = (_a = fileRoutes === null || fileRoutes === void 0 ? void 0 : fileRoutes.files) !== null && _a !== void 0 ? _a : fileRoutes;
+        dirPrefix !== null && dirPrefix !== void 0 ? dirPrefix : (dirPrefix = fileRoutes === null || fileRoutes === void 0 ? void 0 : fileRoutes.dirPrefix);
+        basePath !== null && basePath !== void 0 ? basePath : (basePath = fileRoutes === null || fileRoutes === void 0 ? void 0 : fileRoutes.basePath);
+    }
+    basePath !== null && basePath !== void 0 ? basePath : (basePath = '/');
+    /* eslint-disable react-hooks/rules-of-hooks */
+    const pageRoutes = useMemo(() => createPageRoutes(routes, basePath, dirPrefix), [routes, basePath, dirPrefix]);
+    /* eslint-enable react-hooks/rules-of-hooks */
+    let foundRoute, foundRouteDetails;
+    for (let i = 0; i < pageRoutes.length; i++) {
+        foundRouteDetails = matchPath(serverProps.pathname, pageRoutes[i]);
+        if (foundRouteDetails) {
+            foundRoute = pageRoutes[i];
+            break;
+        }
+    }
+    if (foundRoute) {
+        request.ctx.router.routeRendered = true;
+        request.ctx.router.routeParams = foundRouteDetails.params;
+        return (React.createElement(RouteParamsProvider, { routeParams: foundRouteDetails.params },
+            React.createElement(foundRoute.component, { params: foundRouteDetails.params, ...serverProps })));
+    }
+    return null;
+}
+export function createPageRoutes(pages, topLevelPath = '*', dirPrefix) {
+    const topLevelPrefix = topLevelPath.replace('*', '').replace(/\/$/, '');
+    const keys = Object.keys(pages);
+    const commonRoutePrefix = dirPrefix !== null && dirPrefix !== void 0 ? dirPrefix : findRoutePrefix(keys);
+    const routes = keys
+        .map((key) => {
+        const path = extractPathFromRoutesKey(key, commonRoutePrefix);
+        /**
+         * Catch-all routes [...handle].jsx don't need an exact match
+         * https://reactrouter.com/core/api/Route/exact-bool
+         */
+        const exact = !/\[(?:[.]{3})(\w+?)\]/.test(key);
+        if (!pages[key].default && !pages[key].api) {
+            log === null || log === void 0 ? void 0 : log.warn(`${key} doesn't export a default React component or an API function`);
+        }
+        return {
+            path: topLevelPrefix + path,
+            component: pages[key].default,
+            exact,
+        };
+    })
+        .filter((route) => route.component);
+    /**
+     * Place static paths BEFORE dynamic paths to grant priority.
+     */
+    return [
+        ...routes.filter((route) => !route.path.includes(':')),
+        ...routes.filter((route) => route.path.includes(':')),
+    ];
+}

package/dist/esnext/foundation/FileSessionStorage/FileSessionStorage.d.ts

@@ -0,0 +1,6 @@
+import type { SessionStorageAdapter } from '../session/session';
+import type { CookieOptions } from '../Cookie/Cookie';
+import { Logger } from '../../utilities/log';
+/** The `FileSessionStorage` component persists session data to the file system.
+ */
+export declare const FileSessionStorage: (name: string, dir: string, cookieOptions: CookieOptions) => (log: Logger) => SessionStorageAdapter;