@shopify/hydrogen 0.11.1 → 0.13.1

package/dist/esnext/streaming.server.d.ts

@@ -5,17 +5,20 @@ export declare const createFromReadableStream: (rs: ReadableStream<Uint8Array>)
 };
 declare type StreamOptions = {
     nonce?: string;
-    onCompleteShell?: () => void;
-    onCompleteAll?: () => void;
-    onError?: (error: Error) => void;
     bootstrapScripts?: string[];
     bootstrapModules?: string[];
+    onError?: (error: Error) => void;
 };
-export declare const ssrRenderToPipeableStream: (App: JSX.Element, options: StreamOptions) => {
+export declare const ssrRenderToPipeableStream: (App: JSX.Element, options: StreamOptions & {
+    onAllReady?: (() => void) | undefined;
+    onShellReady?: (() => void) | undefined;
+    onShellError?: ((error: Error) => void) | undefined;
+}) => {
     pipe: Writable['pipe'];
 };
-export declare const ssrRenderToReadableStream: (App: JSX.Element, options: StreamOptions) => ReadableStream<Uint8Array>;
-export declare function supportsReadableStream(): boolean;
+export declare const ssrRenderToReadableStream: (App: JSX.Element, options: StreamOptions) => Promise<ReadableStream<Uint8Array> & {
+    allReady: Promise<void>;
+}>;
 export declare function isStreamingSupported(): Promise<boolean>;
 export declare function bufferReadableStream(reader: ReadableStreamDefaultReader, cb?: (chunk: string) => void): Promise<string>;
 export {};

package/dist/esnext/streaming.server.js

@@ -12,34 +12,9 @@ export const rscRenderToReadableStream = _rscRenderToReadableStream;
 export const createFromReadableStream = _createFromReadableStream;
 export const ssrRenderToPipeableStream = _ssrRenderToPipeableStream;
 export const ssrRenderToReadableStream = _ssrRenderToReadableStream;
-export function supportsReadableStream() {
-    try {
-        new ReadableStream();
-        return true;
-    }
-    catch (_) {
-        return false;
-    }
-}
-let cachedStreamingSupport;
 export async function isStreamingSupported() {
-    if (cachedStreamingSupport === undefined) {
-        try {
-            const rs = new ReadableStream({
-                start(controller) {
-                    controller.close();
-                },
-            });
-            // This will throw in CFW until streaming
-            // is supported. It works in Miniflare.
-            await new Response(rs).text();
-            cachedStreamingSupport = true;
-        }
-        catch (_) {
-            cachedStreamingSupport = false;
-        }
-    }
-    return cachedStreamingSupport;
+    var _a, _b;
+    return Boolean((_b = (_a = globalThis.Oxygen) === null || _a === void 0 ? void 0 : _a.env) === null || _b === void 0 ? void 0 : _b.HYDROGEN_ENABLE_WORKER_STREAMING);
 }
 export async function bufferReadableStream(reader, cb) {
     const decoder = new TextDecoder();

package/dist/esnext/types.d.ts

@@ -3,10 +3,10 @@ import type { ServerResponse } from 'http';
 import type { Logger } from './utilities/log/log';
 import type { ServerComponentRequest } from './framework/Hydration/ServerComponentRequest.server';
 import type { ServerComponentResponse } from './framework/Hydration/ServerComponentResponse.server';
-import type { Metafield, Image, MediaContentType } from './graphql/types/types';
+import type { Metafield, ProductVariant, Product, MediaImage } from './storefront-api-types';
 declare type CommonOptions = {
     App: any;
-    pages?: ImportGlobEagerOutput;
+    routes?: ImportGlobEagerOutput;
     request: ServerComponentRequest;
     componentResponse: ServerComponentResponse;
     log: Logger;
@@ -36,7 +36,7 @@ export declare type Hook = (params: {
 } & Record<string, any>) => any | Promise<any>;
 export declare type ImportGlobEagerOutput = Record<string, Record<'default' | 'api', any>>;
 export declare type ServerHandlerConfig = {
-    pages?: ImportGlobEagerOutput;
+    routes?: ImportGlobEagerOutput;
     shopifyConfig: ShopifyConfig;
 };
 export declare type ClientHandlerConfig = {
@@ -50,21 +50,6 @@ export interface GraphQLConnection<T> {
         node: T;
     }[];
 }
-export interface MediaImage {
-    __typename?: string;
-    id?: string;
-    mediaContentType?: MediaContentType;
-    data?: Pick<Image, 'altText' | 'url' | 'id' | 'width' | 'height'>;
-}
-interface ProductVariant {
-    __typename?: string;
-}
-interface Product {
-    __typename?: string;
-}
-export declare type RawMetafield = Omit<Partial<Metafield>, 'reference'> & {
-    reference?: MediaImage | ProductVariant | Product | null;
-};
 export declare type ParsedMetafield = Omit<Partial<Metafield>, 'value' | 'reference'> & {
     value?: string | number | boolean | Record<any, string> | Date | Rating | Measurement;
     reference?: MediaImage | ProductVariant | Product | null;

package/dist/esnext/utilities/apiRoutes.d.ts

@@ -1,7 +1,9 @@
-import { ImportGlobEagerOutput } from '../types';
+import { ImportGlobEagerOutput, ShopifyConfig } from '../types';
+import type { ASTNode } from 'graphql';
 declare type RouteParams = Record<string, string>;
 declare type RequestOptions = {
     params: RouteParams;
+    queryShop: (args: QueryShopArgs) => Promise<any>;
 };
 declare type ResourceGetter = (request: Request, requestOptions: RequestOptions) => Promise<Response | Object | String>;
 interface HydrogenApiRoute {
@@ -14,7 +16,21 @@ export declare type ApiRouteMatch = {
     hasServerComponent: boolean;
     params: RouteParams;
 };
-export declare function getApiRoutesFromPages(pages: ImportGlobEagerOutput | undefined, topLevelPath?: string): Array<HydrogenApiRoute>;
+export declare function getApiRoutes(pages: ImportGlobEagerOutput | undefined, topLevelPath?: string): Array<HydrogenApiRoute>;
 export declare function getApiRouteFromURL(url: URL, routes: Array<HydrogenApiRoute>): ApiRouteMatch | null;
-export declare function renderApiRoute(request: Request, route: ApiRouteMatch): Promise<Response>;
+/** The `queryShop` utility is a function that helps you query the Storefront API.
+ * It's similar to the `useShopQuery` hook, which is available in server components.
+ * To use `queryShop`, pass `shopifyConfig` to `renderHydrogen` inside `App.server.jsx`.
+ */
+interface QueryShopArgs {
+    /** A string of the GraphQL query.
+     * If no query is provided, then the `useShopQuery` makes no calls to the Storefront API.
+     */
+    query: ASTNode | string;
+    /** An object of the variables for the GraphQL query. */
+    variables?: Record<string, any>;
+    /** A string corresponding to a valid locale identifier like `en-us` used to make the request. */
+    locale?: string;
+}
+export declare function renderApiRoute(request: Request, route: ApiRouteMatch, shopifyConfig: ShopifyConfig): Promise<Response>;
 export {};

package/dist/esnext/utilities/apiRoutes.js

@@ -1,16 +1,17 @@
 import { matchPath } from './matchPath';
 import { getLoggerWithContext, logServerResponse } from '../utilities/log/';
+import { fetchBuilder, graphqlRequestBody } from './fetch';
 let memoizedRoutes = [];
 let memoizedPages = {};
-export function getApiRoutesFromPages(pages, topLevelPath = '*') {
+export function getApiRoutes(pages, topLevelPath = '*') {
     if (!pages || memoizedPages === pages)
         return memoizedRoutes;
     const topLevelPrefix = topLevelPath.replace('*', '').replace(/\/$/, '');
     const routes = Object.keys(pages)
         .filter((key) => pages[key].api)
         .map((key) => {
-        const path = key
-            .replace('./pages', '')
+        let path = key
+            .replace('./routes', '')
             .replace(/\.server\.(t|j)sx?$/, '')
             /**
              * Replace /index with /
@@ -25,6 +26,8 @@ export function getApiRoutesFromPages(pages, topLevelPath = '*') {
              * Convert /[handle].jsx and /[...handle].jsx to /:handle.jsx for react-router-dom
              */
             .replace(/\[(?:[.]{3})?(\w+?)\]/g, (_match, param) => `:${param}`);
+        if (path.endsWith('/') && path !== '/')
+            path = path.substring(0, path.length - 1);
         /**
          * Catch-all routes [...handle].jsx don't need an exact match
          * https://reactrouter.com/core/api/Route/exact-bool
@@ -61,11 +64,30 @@ export function getApiRouteFromURL(url, routes) {
         hasServerComponent: foundRoute.hasServerComponent,
     };
 }
-export async function renderApiRoute(request, route) {
+function queryShopBuilder(shopifyConfig) {
+    return async function queryShop({ query, variables, locale, }) {
+        var _a;
+        const { storeDomain, storefrontApiVersion, storefrontToken, defaultLocale } = shopifyConfig;
+        const fetcher = fetchBuilder(`https://${storeDomain}/api/${storefrontApiVersion}/graphql.json`, {
+            method: 'POST',
+            body: graphqlRequestBody(query, variables),
+            headers: {
+                'X-Shopify-Storefront-Access-Token': storefrontToken,
+                'Accept-Language': (_a = locale) !== null && _a !== void 0 ? _a : defaultLocale,
+                'Content-Type': 'application/json',
+            },
+        });
+        return await fetcher();
+    };
+}
+export async function renderApiRoute(request, route, shopifyConfig) {
     let response;
     const log = getLoggerWithContext(request);
     try {
-        response = await route.resource(request, { params: route.params });
+        response = await route.resource(request, {
+            params: route.params,
+            queryShop: queryShopBuilder(shopifyConfig),
+        });
         if (!(response instanceof Response)) {
             if (typeof response === 'string' || response instanceof String) {
                 response = new Response(response);

package/dist/esnext/utilities/devtools.d.ts

@@ -0,0 +1,11 @@
+export declare type DevServerMessage = {
+    type: 'warn';
+    data: string;
+} | {
+    type: 'error';
+    data: {
+        message: string;
+        stack: string;
+    };
+};
+export declare function sendMessageToClient(message: DevServerMessage): void;

package/dist/esnext/utilities/devtools.js

@@ -0,0 +1,11 @@
+export function sendMessageToClient(message) {
+    // @ts-ignore
+    const devServer = globalThis.__viteDevServer;
+    if (devServer) {
+        devServer.ws.send({
+            type: 'custom',
+            event: 'hydrogen',
+            data: message,
+        });
+    }
+}

package/dist/esnext/utilities/fetch.d.ts

@@ -1,4 +1,10 @@
 import { ASTNode } from 'graphql';
-export declare function fetchBuilder<T>(request: Request): () => Promise<T>;
+declare type FetchInit = {
+    body?: string;
+    method?: string;
+    headers?: Record<string, string>;
+};
+export declare function fetchBuilder<T>(url: string, options?: FetchInit): () => Promise<T>;
 export declare function graphqlRequestBody(query: ASTNode | string, variables?: Record<string, any>): string;
 export declare function decodeShopifyId(id: string): string;
+export {};

package/dist/esnext/utilities/fetch.js

@@ -1,17 +1,16 @@
 import { print } from 'graphql';
 import { LIB_VERSION } from '../version';
-export function fetchBuilder(request) {
-    const defaultHeaders = {
-        'content-type': 'application/json',
-        'user-agent': `Hydrogen ${LIB_VERSION}`,
+const defaultHeaders = {
+    'content-type': 'application/json',
+    'user-agent': `Hydrogen ${LIB_VERSION}`,
+};
+export function fetchBuilder(url, options = {}) {
+    const requestInit = {
+        ...options,
+        headers: { ...defaultHeaders, ...options.headers },
     };
-    for (const [property, value] of Object.entries(defaultHeaders)) {
-        if (!request.headers.has(property)) {
-            request.headers.append(property, value);
-        }
-    }
     return async () => {
-        const response = await fetch(request.url, request);
+        const response = await fetch(url, requestInit);
         if (!response.ok) {
             throw response;
         }
@@ -27,14 +26,6 @@ export function graphqlRequestBody(query, variables) {
     });
 }
 export function decodeShopifyId(id) {
-    // Start fix: for SFAPI 2022-01. Remove when upgrading to 2022-04
-    if (!id.startsWith('gid://')) {
-        id =
-            typeof btoa !== 'undefined'
-                ? btoa(id)
-                : Buffer.from(id, 'base64').toString('ascii');
-    }
-    // End fix
     if (!id.startsWith('gid://')) {
         throw new Error('invalid Shopify ID');
     }

package/dist/esnext/utilities/flattenConnection/flattenConnection.d.ts

@@ -1,5 +1,6 @@
-import { GraphQLConnection } from '../../types';
+import type { GraphQLConnection } from '../../types';
+import type { PartialDeep } from 'type-fest';
 /**
  * The `flattenConnection` utility transforms a connection object from the Storefront API (for example, [Product-related connections](/api/storefront/reference/products/product)) into a flat array of nodes.
  */
-export declare function flattenConnection<T>(connection: GraphQLConnection<T>): T[];
+export declare function flattenConnection<T>(connection: PartialDeep<GraphQLConnection<T>>): PartialDeep<T>[];

package/dist/esnext/utilities/flattenConnection/flattenConnection.js

@@ -2,6 +2,10 @@
  * The `flattenConnection` utility transforms a connection object from the Storefront API (for example, [Product-related connections](/api/storefront/reference/products/product)) into a flat array of nodes.
  */
 export function flattenConnection(connection) {
-    var _a;
-    return ((_a = connection.edges) !== null && _a !== void 0 ? _a : []).map((edge) => edge.node);
+    return (connection.edges || []).map((edge) => {
+        if (!(edge === null || edge === void 0 ? void 0 : edge.node)) {
+            throw new Error('Connection edges must contain nodes');
+        }
+        return edge.node;
+    });
 }

package/dist/esnext/utilities/graphql-tracker.d.ts

@@ -0,0 +1,17 @@
+import type { ASTNode } from 'graphql';
+export declare const TIMEOUT_MS = 2000;
+declare type TrackerParams = {
+    query: ASTNode;
+    data: {
+        data: unknown;
+    };
+    onUnusedData?: (params: {
+        queryName: string;
+        properties: string[];
+    }) => void;
+};
+export declare function injectGraphQLTracker({ query, data, onUnusedData, }: TrackerParams): (check?: (params: {
+    queryName: string;
+    properties: string[];
+}) => void) => void;
+export {};

package/dist/esnext/utilities/graphql-tracker.js

@@ -0,0 +1,119 @@
+export const TIMEOUT_MS = 2000;
+export function injectGraphQLTracker({ query, data, onUnusedData, }) {
+    var _a;
+    const info = convertQueryToResolveInfo(query);
+    // E.g. ['shop.stuff.myString']
+    const requestedFields = getFieldList(info.nodes, info.fragments);
+    // Remove the last key of each path to avoid proxying primitive
+    // values. Reverse order to avoid accessing already defined
+    // proxies (i.e. handle child properties before parent properties)
+    // E.g. `shop.stuff.myString` => `shop.stuff`
+    const uniqueFieldPaths = [
+        ...new Set(requestedFields.map((path) => path.split('.').slice(0, -1).join('.'))),
+    ].reverse();
+    const queryName = ((_a = findOperationDefinition(query).name) === null || _a === void 0 ? void 0 : _a.value) || '';
+    // Record fields that are read in the proxy to compare later.
+    const readFieldsMap = {};
+    let isCheckedOnce = false;
+    const checkFields = (check = onUnusedData) => {
+        isCheckedOnce = true;
+        const properties = requestedFields
+            .filter((prop) => !readFieldsMap[prop] && !prop.endsWith('.__typename'))
+            .map((prop) => prop.replace(/\.edges\./g, '.').replace(/\.node\./g, '.'));
+        if (properties.length > 0) {
+            return check({ queryName, properties });
+        }
+    };
+    let readTimeout;
+    uniqueFieldPaths.forEach((fieldPath) => deepTransform(data, 'data.' + fieldPath, (value) => {
+        if (typeof value !== 'object' || value === null)
+            return value;
+        return new Proxy(value, {
+            get(target, prop) {
+                if (typeof prop === 'string') {
+                    const fullPath = fieldPath + '.' + prop;
+                    if (!readFieldsMap[fullPath]) {
+                        readFieldsMap[fullPath] = true;
+                        if (onUnusedData && !isCheckedOnce) {
+                            clearTimeout(readTimeout);
+                            readTimeout = setTimeout(checkFields, TIMEOUT_MS);
+                        }
+                    }
+                }
+                return target[prop];
+            },
+        });
+    }));
+    return checkFields;
+}
+function findOperationDefinition(query) {
+    return query.definitions.find((def) => def.kind === 'OperationDefinition');
+}
+function convertQueryToResolveInfo(query) {
+    var _a;
+    return {
+        // Root of the selection nodes
+        nodes: (_a = findOperationDefinition(query)) === null || _a === void 0 ? void 0 : _a.selectionSet.selections,
+        // Collection of all the fragments in this query
+        fragments: query.definitions.reduce((acc, current) => {
+            if (current.kind === 'FragmentDefinition') {
+                acc[current.name.value] = current;
+            }
+            return acc;
+        }, {}),
+    };
+}
+/**
+ * Extracts the selection fields from a query AST as a list of dot-separated paths.
+ * @param selectionNodes - Selection nodes from the AST
+ * @param fragments - Fragments from the AST
+ * @param path - Accummulated path for recursion
+ * @returns A plain JS array representing the selection fields
+ */
+function getFieldList(nodes, fragments = {}, path = '') {
+    return nodes.reduce((acc, node) => {
+        var _a, _b, _c, _d, _e;
+        let nextPath = path;
+        let nextNodes;
+        if (node.kind === 'FragmentSpread') {
+            nextNodes = fragments[node.name.value].selectionSet.selections;
+        }
+        else if (node.kind === 'InlineFragment') {
+            nextNodes = (_a = node.selectionSet) === null || _a === void 0 ? void 0 : _a.selections;
+        }
+        else if (node.kind === 'Field') {
+            nextNodes = (_b = node.selectionSet) === null || _b === void 0 ? void 0 : _b.selections;
+            const name = (_d = (_c = node.alias) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : (_e = node.name) === null || _e === void 0 ? void 0 : _e.value;
+            nextPath = path ? `${path}.${name}` : name;
+            if (!nextNodes)
+                acc.push(nextPath); // This is a leaf
+        }
+        if (nextNodes)
+            acc.push(...getFieldList(nextNodes, fragments, nextPath));
+        return acc;
+    }, []);
+}
+/**
+ * Transform a nested property in a given object (in place).
+ * @param input - Object to transform
+ * @param path - Dot-separated path to the nested property
+ * @param valueTransform - Transformer function
+ */
+function deepTransform(input, path, valueTransform) {
+    const keys = Array.isArray(path) ? path : path.split('.');
+    let obj = input;
+    let key;
+    for (let index = 0; !!obj && index < keys.length; index++) {
+        key = keys[index];
+        if (index === keys.length - 1) {
+            // Last property, transform value
+            obj[key] = valueTransform(obj[key]);
+        }
+        else if (Array.isArray(obj[key])) {
+            // We've found an array in the middle, run this recursively
+            const subKeys = keys.slice(index + 1);
+            obj[key].forEach((v) => deepTransform(v, subKeys, valueTransform));
+        }
+        obj = obj[key];
+    }
+}

package/dist/esnext/utilities/image_size.d.ts

@@ -1,4 +1,5 @@
-import { Image as ImageType } from '../graphql/types/types';
+import type { Image as ImageType } from '../storefront-api-types';
+import type { PartialDeep } from 'type-fest';
 export declare type Width = string | 'original';
 export declare type Height = string | 'original';
 export declare type Crop = 'top' | 'bottom' | 'left' | 'right' | 'center';
@@ -23,7 +24,7 @@ export interface ImageLoaderOptions {
 export declare function addImageSizeParametersToUrl(url: string, { width, height, crop, scale, format }: ImageSizeOptions): string;
 export declare function shopifyImageLoader({ src, options }: ImageLoaderOptions): string;
 export declare function useImageUrl(src?: string, options?: ImageSizeOptions): string | undefined;
-export declare function getShopifyImageDimensions(image: Pick<ImageType, 'altText' | 'url' | 'id' | 'width' | 'height'>, options?: ImageSizeOptions): {
-    width: import("../graphql/types/types").Maybe<number> | undefined;
-    height: import("../graphql/types/types").Maybe<number> | undefined;
+export declare function getShopifyImageDimensions(image: Pick<PartialDeep<ImageType>, 'altText' | 'url' | 'id' | 'width' | 'height'>, options?: ImageSizeOptions): {
+    width: import("../storefront-api-types").Maybe<number> | undefined;
+    height: import("../storefront-api-types").Maybe<number> | undefined;
 };

package/dist/esnext/utilities/log/log-query-timeline.d.ts

@@ -1,7 +1,7 @@
 import { ServerComponentRequest } from '../../framework/Hydration/ServerComponentRequest.server';
 import { QueryKey } from '../../types';
 import type { RenderType } from './log';
-export declare type TimingType = 'requested' | 'resolved' | 'rendered' | 'preload' | 'expired';
+export declare type TimingType = 'requested' | 'resolved' | 'rendered' | 'preload';
 export declare type QueryTiming = {
     name: string;
     timingType: TimingType;

package/dist/esnext/utilities/log/log-query-timeline.js

@@ -9,7 +9,6 @@ const TIMING_MAPPING = {
     rendered: 'Rendered',
     resolved: 'Resolved',
     preload: 'Preload',
-    expired: 'Expired',
 };
 export function collectQueryTimings(request, queryKey, timingType, duration) {
     request.ctx.queryTimings.push({
@@ -45,7 +44,7 @@ export function logQueryTimings(type, request) {
             }
             const loadColor = query.timingType === 'preload' ? green : color;
             const duration = query.duration;
-            log.debug(color(`│ ${`${(query.timestamp - requestStartTime).toFixed(2)}ms`.padEnd(10)} ${loadColor(TIMING_MAPPING[query.timingType].padEnd(10))} ${query.name}${query.timingType === 'resolved' || query.timingType === 'expired'
+            log.debug(color(`│ ${`${(query.timestamp - requestStartTime).toFixed(2)}ms`.padEnd(10)} ${loadColor(TIMING_MAPPING[query.timingType].padEnd(10))} ${query.name}${query.timingType === 'resolved'
                 ? ` (Took ${duration === null || duration === void 0 ? void 0 : duration.toFixed(2)}ms)`
                 : ''}`));
             // SSR + RSC render path generates 2 `load` and `render` for each query

package/dist/esnext/utilities/log/log.d.ts

@@ -11,6 +11,7 @@ export declare type LoggerOptions = {
     showCacheControlHeader?: boolean;
     showCacheApiStatus?: boolean;
     showQueryTiming?: boolean;
+    showUnusedQueryProperties?: boolean;
 };
 export declare type RenderType = 'str' | 'rsc' | 'ssr' | 'api';
 export declare const log: Logger;

package/dist/esnext/utilities/log/utils.js

@@ -1,5 +1,8 @@
 export function findQueryName(key) {
     const decodeKey = decodeURIComponent(key);
+    if (key.length < 100) {
+        return key.replace('"__QUERY_CACHE_ID__"', '').replace(/"/g, '');
+    }
     const match = decodeKey.match(/query ([^\s\()]*)\s?(|\(\{)/);
     if (match && match.length > 1) {
         return match[1];

package/dist/esnext/utilities/parseMetafieldValue/parseMetafieldValue.d.ts

@@ -1,5 +1,6 @@
-import { RawMetafield } from '../../types';
+import type { Metafield } from '../../storefront-api-types';
+import type { PartialDeep } from 'type-fest';
 /**
  * The `parseMetafieldValue` function parses a [Metafield](/api/storefront/reference/common-objects/metafield)'s `value` from a string into a sensible type corresponding to the [Metafield](/api/storefront/reference/common-objects/metafield)'s `type`.
  */
-export declare function parseMetafieldValue(metafield: Partial<RawMetafield>): any;
+export declare function parseMetafieldValue(metafield: PartialDeep<Metafield>): any;

package/dist/esnext/utilities/video_parameters.js

@@ -13,10 +13,6 @@ export function addParametersToEmbeddedVideoUrl(url, parameters) {
     return `${url}?${params}`;
 }
 export function useEmbeddedVideoUrl(url, parameters) {
-    // Ensure a youtube shortened url is changed to an iFrame compatible embed link.
-    // TODO: Fix is needed for SFAPI version 2022-01. Starting 2022-04 embeddedUrl has been marked as deprecated and replaced with
-    // embedUrl. When the pinned SFAPI version is 2022-04 line can be removed in favor of changes on PR #455
-    url = url.replace(/youtu\.be/, 'www.youtube.com/embed');
     return useMemo(() => {
         if (!parameters) {
             return url;

package/dist/esnext/version.d.ts

@@ -1 +1 @@
-export declare const LIB_VERSION = "0.11.1";
+export declare const LIB_VERSION = "0.13.1";

package/dist/esnext/version.js

@@ -1 +1 @@
-export const LIB_VERSION = '0.11.1';
+export const LIB_VERSION = '0.13.1';

package/dist/node/entry-server.d.ts

@@ -14,9 +14,10 @@ interface RequestHandlerOptions {
     dev?: boolean;
     context?: RuntimeContext;
     nonce?: string;
+    buyerIpHeader?: string;
 }
 export interface RequestHandler {
     (request: Request | IncomingMessage, options: RequestHandlerOptions): Promise<Response | undefined>;
 }
-export declare const renderHydrogen: (App: any, { pages }: ServerHandlerConfig) => RequestHandler;
+export declare const renderHydrogen: (App: any, { shopifyConfig, routes }: ServerHandlerConfig) => RequestHandler;
 export default renderHydrogen;