npm - @shopify/hydrogen - Versions diffs - 0.16.1 → 0.17.0 - Mend

@shopify/hydrogen 0.16.1 → 0.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (130) hide show

package/dist/esnext/components/Video/Video.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import React from 'react';
 import { useImageUrl } from '../../utilities';
 /**
- * The `Video` component renders a `video` for the Storefront API's [Video object](/api/storefront/reference/products/video).
+ * The `Video` component renders a `video` for the Storefront API's [Video object](https://shopify.dev/api/storefront/reference/products/video).
  */
 export function Video(props) {
     var _a;

package/dist/esnext/entry-client.js CHANGED Viewed

@@ -3,7 +3,7 @@ import React, { Suspense, useState, StrictMode, Fragment, } from 'react';
 import { hydrateRoot } from 'react-dom/client';
 import { ErrorBoundary } from 'react-error-boundary';
 import { useServerResponse } from './framework/Hydration/rsc';
-import { ServerStateProvider } from './foundation/ServerStateProvider';
+import { ServerPropsProvider } from './foundation/ServerPropsProvider';
 const DevTools = React.lazy(() => import('./components/DevTools'));
 const renderHydrogen = async (ClientWrapper, config) => {
     const root = document.getElementById('root');
@@ -42,12 +42,12 @@ const renderHydrogen = async (ClientWrapper, config) => {
 };
 export default renderHydrogen;
 function Content({ clientWrapper: ClientWrapper = ({ children }) => children, }) {
-    const [serverState, setServerState] = useState({
+    const [serverProps, setServerProps] = useState({
         pathname: window.location.pathname,
         search: window.location.search,
     });
-    const response = useServerResponse(serverState);
-    return (React.createElement(ServerStateProvider, { serverState: serverState, setServerState: setServerState },
+    const response = useServerResponse(serverProps);
+    return (React.createElement(ServerPropsProvider, { initialServerProps: serverProps, setServerPropsForRsc: setServerProps },
         React.createElement(ClientWrapper, null, response.readRoot())));
 }
 function Error({ error }) {

package/dist/esnext/entry-server.d.ts CHANGED Viewed

@@ -19,5 +19,5 @@ interface RequestHandlerOptions {
 export interface RequestHandler {
     (request: Request | IncomingMessage, options: RequestHandlerOptions): Promise<Response | undefined>;
 }
-export declare const renderHydrogen: (App: any, { shopifyConfig, routes, serverAnalyticsConnectors }: ServerHandlerConfig) => RequestHandler;
+export declare const renderHydrogen: (App: any, { shopifyConfig, routes, serverAnalyticsConnectors, session, }: ServerHandlerConfig) => RequestHandler;
 export default renderHydrogen;

package/dist/esnext/entry-server.js CHANGED Viewed

@@ -7,7 +7,7 @@ import { ServerComponentResponse } from './framework/Hydration/ServerComponentRe
 import { ServerComponentRequest } from './framework/Hydration/ServerComponentRequest.server';
 import { preloadRequestCacheData, ServerRequestProvider, } from './foundation/ServerRequestProvider';
 import { getApiRouteFromURL, renderApiRoute, getApiRoutes, } from './utilities/apiRoutes';
-import { ServerStateProvider } from './foundation/ServerStateProvider';
+import { ServerPropsProvider } from './foundation/ServerPropsProvider';
 import { isBotUA } from './utilities/bot-ua';
 import { setContext, setCache } from './framework/runtime';
 import { setConfig } from './framework/config';
@@ -16,17 +16,20 @@ import { RSC_PATHNAME, EVENT_PATHNAME, EVENT_PATHNAME_REGEX } from './constants'
 import { stripScriptsFromTemplate } from './utilities/template';
 import { Analytics } from './foundation/Analytics/Analytics.server';
 import { ServerAnalyticsRoute } from './foundation/Analytics/ServerAnalyticsRoute.server';
+import { getSyncSessionApi } from './foundation/session/session';
 const DOCTYPE = '<!DOCTYPE html>';
 const CONTENT_TYPE = 'Content-Type';
 const HTML_CONTENT_TYPE = 'text/html; charset=UTF-8';
-export const renderHydrogen = (App, { shopifyConfig, routes, serverAnalyticsConnectors }) => {
+export const renderHydrogen = (App, { shopifyConfig, routes, serverAnalyticsConnectors, session, }) => {
     const handleRequest = async function (rawRequest, options) {
         const { indexTemplate, streamableResponse, dev, cache, context, nonce, buyerIpHeader, } = options;
         const request = new ServerComponentRequest(rawRequest);
         request.ctx.buyerIpHeader = buyerIpHeader;
         const url = new URL(request.url);
         const log = getLoggerWithContext(request);
+        const sessionApi = session ? session(log) : undefined;
         const componentResponse = new ServerComponentResponse();
+        request.ctx.session = getSyncSessionApi(request, componentResponse, log, sessionApi);
         /**
          * Inject the cache & context into the module loader so we can pull it out for subrequests.
          */
@@ -44,7 +47,7 @@ export const renderHydrogen = (App, { shopifyConfig, routes, serverAnalyticsConn
             // If it does, only render the API route if the request method is GET
             if (apiRoute &&
                 (!apiRoute.hasServerComponent || request.method !== 'GET')) {
-                const apiResponse = await renderApiRoute(request, apiRoute, shopifyConfig);
+                const apiResponse = await renderApiRoute(request, apiRoute, shopifyConfig, sessionApi);
                 return apiResponse instanceof Request
                     ? handleRequest(apiResponse, options)
                     : apiResponse;
@@ -131,7 +134,11 @@ async function render(url, { App, routes, request, componentResponse, log, templ
     headers[CONTENT_TYPE] = HTML_CONTENT_TYPE;
     html = applyHtmlHead(html, request.ctx.head, template);
     if (flight) {
-        html = html.replace('</body>', `${flightContainer({ init: true, nonce, chunk: flight })}</body>`);
+        html = html.replace('</body>', () => `${flightContainer({
+            init: true,
+            nonce,
+            chunk: flight,
+        })}</body>`);
     }
     postRequestTasks('ssr', status, request, componentResponse);
     return new Response(html, {
@@ -410,7 +417,7 @@ function buildAppSSR({ App, state, request, response, log, routes }, htmlOptions
     const RscConsumer = () => rscResponse.readRoot();
     const AppSSR = (React.createElement(Html, { ...htmlOptions },
         React.createElement(ServerRequestProvider, { request: request, isRSC: false },
-            React.createElement(ServerStateProvider, { serverState: state, setServerState: () => { } },
+            React.createElement(ServerPropsProvider, { initialServerProps: state, setServerPropsForRsc: () => { } },
                 React.createElement(PreloadQueries, { request: request },
                     React.createElement(Suspense, { fallback: null },
                         React.createElement(RscConsumer, null)),

package/dist/esnext/foundation/Analytics/Analytics.server.js CHANGED Viewed

@@ -1,7 +1,8 @@
-import React from 'react';
+import * as React from 'react';
 import { useServerAnalytics } from './hook';
 import { Analytics as AnalyticsClient } from './Analytics.client';
 import { useServerRequest } from '../ServerRequestProvider';
+import AnalyticsErrorBoundary from '../AnalyticsErrorBoundary.client';
 const DELAY_KEY = 'analytics-delay';
 export function Analytics() {
     const cache = useServerRequest().ctx.cache;
@@ -34,5 +35,6 @@ export function Analytics() {
         }
     });
     const analyticsData = useServerAnalytics();
-    return React.createElement(AnalyticsClient, { analyticsDataFromServer: analyticsData });
+    return (React.createElement(AnalyticsErrorBoundary, null,
+        React.createElement(AnalyticsClient, { analyticsDataFromServer: analyticsData })));
 }

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 in 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 ADDED Viewed

@@ -0,0 +1,66 @@
+import { parse, stringify as stringifyCookie } from 'worktop/cookie';
+import { log } from '../../utilities/log';
+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 = JSON.parse(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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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/FileSessionStorage/FileSessionStorage.d.ts ADDED Viewed

@@ -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;

package/dist/esnext/foundation/FileSessionStorage/FileSessionStorage.js ADDED Viewed

@@ -0,0 +1,148 @@
+import { Cookie } from '../Cookie/Cookie';
+import { v4 as uid } from 'uuid';
+import path from 'path';
+import { promises as fsp } from 'fs';
+async function wait() {
+    return new Promise((resolve) => setTimeout(resolve));
+}
+let writingLock = false;
+/**
+ * Concurrent requests with the same session can write interfere
+ * writing at the same file, which crashes the process. This locks
+ * so that only one file can be written at a time.
+ *
+ * A better solution would be to have a lock only for the same session.
+ */
+async function startFileLock(promise) {
+    if (!writingLock) {
+        writingLock = true;
+        await promise();
+        writingLock = false;
+    }
+    else {
+        await wait();
+        await startFileLock(promise);
+    }
+}
+/** The `FileSessionStorage` component persists session data to the file system.
+ */
+export const FileSessionStorage = function (
+/** The name of the cookie stored in the browser. */
+name,
+/** A directory to store the session files within. Each session is stored in a separate file on the file system. */
+dir,
+/** An optional object to configure [how the cookie is persisted in the browser](https://shopify.dev/api/hydrogen/components/framework/cookie#cookie-options). */
+cookieOptions) {
+    return function (log) {
+        const cookie = new Cookie(name, cookieOptions);
+        let data;
+        return {
+            async get(request) {
+                if (data)
+                    return data;
+                const sid = cookie.getSessionId(request) || uid();
+                const file = getSessionFile(dir, sid);
+                const fileContents = await getFile(file, cookie.expires, log);
+                data = fileContents.data;
+                return data;
+            },
+            async set(request, value) {
+                const sid = cookie.getSessionId(request) || uid();
+                const file = getSessionFile(dir, sid);
+                await writeFile(file, value, cookie.expires);
+                data = value;
+                cookie.setSessionid(sid);
+                return cookie.serialize();
+            },
+            async destroy(request) {
+                const sid = cookie.getSessionId(request);
+                if (sid) {
+                    const file = getSessionFile(dir, sid);
+                    await deleteFile(file);
+                }
+                data = undefined;
+                // @todo - set expires for Date in past
+                return cookie.destroy();
+            },
+        };
+    };
+};
+async function getFile(file, expires, log) {
+    let content = null;
+    const defaultFileContent = {
+        data: {},
+        expires,
+    };
+    await startFileLock(async () => {
+        try {
+            const textContent = await fsp.readFile(file, { encoding: 'utf-8' });
+            try {
+                content = JSON.parse(textContent);
+            }
+            catch (error) {
+                log.warn(`Cannot parse existing session file: ${file}`);
+                content = defaultFileContent;
+            }
+            if (content.expires < new Date().getTime() ||
+                content === defaultFileContent) {
+                await fsp.unlink(file);
+                await fsp.writeFile(file, JSON.stringify(defaultFileContent), {
+                    encoding: 'utf-8',
+                    flag: 'wx',
+                });
+                content = defaultFileContent;
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            await fsp.mkdir(path.dirname(file), { recursive: true });
+            await fsp.writeFile(file, JSON.stringify(defaultFileContent), {
+                encoding: 'utf-8',
+                flag: 'wx',
+            });
+        }
+    });
+    return content ? content : defaultFileContent;
+}
+async function writeFile(file, data, expires) {
+    const content = {
+        data,
+        expires,
+    };
+    await startFileLock(async () => {
+        try {
+            await fsp.mkdir(path.dirname(file), { recursive: true });
+        }
+        catch (error) {
+            // directory already exists
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        try {
+            await fsp.unlink(file);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        await fsp.writeFile(file, JSON.stringify(content), {
+            encoding: 'utf-8',
+            flag: 'wx',
+        });
+    });
+}
+async function deleteFile(file) {
+    try {
+        await startFileLock(async () => {
+            await fsp.unlink(file);
+        });
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+function getSessionFile(dir, sid) {
+    return path.join(dir, sid.slice(0, 3), sid.slice(3));
+}

package/dist/esnext/foundation/MemorySessionStorage/MemorySessionStorage.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import type { SessionStorageAdapter } from '../session/session';
+import type { CookieOptions } from '../Cookie/Cookie';
+/** The `MemorySessionStorage` component stores session data within Hydrogen runtime memory.
+ */
+export declare const MemorySessionStorage: (name: string, options: CookieOptions) => () => SessionStorageAdapter;

package/dist/esnext/foundation/MemorySessionStorage/MemorySessionStorage.js ADDED Viewed

@@ -0,0 +1,53 @@
+import { Cookie } from '../Cookie/Cookie';
+import { v4 as uid } from 'uuid';
+/** The `MemorySessionStorage` component stores session data within Hydrogen runtime memory.
+ */
+export const MemorySessionStorage = 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) {
+    const sessions = new Map();
+    return function () {
+        const cookie = new Cookie(name, options);
+        return {
+            async get(request) {
+                const sid = cookie.getSessionId(request);
+                let sessionData;
+                if (sid && sessions.has(sid)) {
+                    const { expires, data } = sessions.get(sid);
+                    if (expires < new Date().getTime()) {
+                        sessions.delete(sid);
+                        sessionData = {};
+                    }
+                    else {
+                        sessionData = data;
+                    }
+                }
+                else {
+                    sessionData = {};
+                }
+                return sessionData;
+            },
+            async set(request, value) {
+                let sid = cookie.getSessionId(request);
+                if (!sid) {
+                    sid = uid();
+                }
+                sessions.set(sid, {
+                    data: value,
+                    expires: cookie.expires,
+                });
+                cookie.setSessionid(sid);
+                return cookie.serialize();
+            },
+            async destroy(request) {
+                const sid = cookie.getSessionId(request);
+                if (sid) {
+                    sessions.delete(sid);
+                }
+                return cookie.destroy();
+            },
+        };
+    };
+};

package/dist/esnext/foundation/Router/BrowserRouter.client.js CHANGED Viewed

@@ -1,7 +1,7 @@
 import { createBrowserHistory } from 'history';
 import React, { createContext, useContext, useMemo, useState, useEffect, useLayoutEffect, useCallback, } from 'react';
 import { META_ENV_SSR } from '../ssr-interop';
-import { useServerState } from '../useServerState';
+import { useInternalServerProps } from '../useServerProps/use-server-props';
 export const RouterContext = createContext({});
 let isFirstLoad = true;
 const positions = {};
@@ -10,12 +10,12 @@ export const BrowserRouter = ({ history: pHistory, children, }) => {
         return React.createElement(React.Fragment, null, children);
     const history = useMemo(() => pHistory || createBrowserHistory(), [pHistory]);
     const [location, setLocation] = useState(history.location);
-    const { pending, serverState, setServerState } = useServerState();
-    useScrollRestoration(location, pending, serverState);
+    const { pending, locationServerProps, setLocationServerProps } = useInternalServerProps();
+    useScrollRestoration(location, pending, locationServerProps);
     useLayoutEffect(() => {
         const unlisten = history.listen(({ location: newLocation }) => {
             positions[location.key] = window.scrollY;
-            setServerState({
+            setLocationServerProps({
                 pathname: newLocation.pathname,
                 search: location.search,
             });
@@ -49,7 +49,7 @@ function useBeforeUnload(callback) {
         };
     }, [callback]);
 }
-function useScrollRestoration(location, pending, serverState) {
+function useScrollRestoration(location, pending, serverProps) {
     /**
      * Browsers have an API for scroll restoration. We wait for the page to load first,
      * in case the browser is able to restore scroll position automatically, and then
@@ -77,8 +77,8 @@ function useScrollRestoration(location, pending, serverState) {
          * location pointer and serverState match, and pending is false, to do any scrolling.
          */
         const finishedNavigating = !pending &&
-            location.pathname === serverState.pathname &&
-            location.search === serverState.search;
+            location.pathname === serverProps.pathname &&
+            location.search === serverProps.search;
         if (!finishedNavigating) {
             return;
         }
@@ -97,5 +97,5 @@ function useScrollRestoration(location, pending, serverState) {
         }
         // Scroll to the top of new pages
         window.scrollTo(0, 0);
-    }, [location, pending, serverState]);
+    }, [location, pending, serverProps]);
 }

package/dist/esnext/foundation/ServerPropsProvider/ServerPropsProvider.d.ts ADDED Viewed

@@ -0,0 +1,40 @@
+import React, { ReactNode } from 'react';
+declare global {
+    var __DEV__: boolean;
+}
+export interface LocationServerProps {
+    pathname: string;
+    search: string;
+}
+export interface ServerProps {
+    [key: string]: any;
+}
+declare type ServerPropsSetterInput = ((prev: ServerProps) => Partial<ServerProps>) | Partial<ServerProps> | string;
+export interface ServerPropsSetter {
+    (input: ServerPropsSetterInput, propValue?: any): void;
+}
+interface ProposedServerPropsSetter {
+    (input: ServerPropsSetterInput, propValue?: any): LocationServerProps;
+}
+interface BaseServerPropsContextValue {
+    pending: boolean;
+}
+export interface InternalServerPropsContextValue extends BaseServerPropsContextValue {
+    setLocationServerProps: ServerPropsSetter;
+    setServerProps: ServerPropsSetter;
+    serverProps: ServerProps;
+    locationServerProps: LocationServerProps;
+    getProposedLocationServerProps: ProposedServerPropsSetter;
+}
+export interface ServerPropsContextValue extends BaseServerPropsContextValue {
+    serverProps: ServerProps;
+    setServerProps: ServerPropsSetter;
+}
+export declare const ServerPropsContext: React.Context<InternalServerPropsContextValue>;
+interface ServerPropsProviderProps {
+    initialServerProps: LocationServerProps;
+    setServerPropsForRsc: React.Dispatch<React.SetStateAction<LocationServerProps>>;
+    children: ReactNode;
+}
+export declare function ServerPropsProvider({ initialServerProps, setServerPropsForRsc, children, }: ServerPropsProviderProps): JSX.Element;
+export {};