@shopify/hydrogen 0.25.1 → 0.26.0

package/dist/esnext/framework/plugins/vite-plugin-hydrogen-virtual-files.js

@@ -15,20 +15,25 @@ export const VIRTUAL_PROXY_HYDROGEN_ROUTES_ID = VIRTUAL_PREFIX + PROXY_PREFIX +
 export default (pluginOptions) => {
     let config;
     let server;
+    let resolvedConfigPath;
     return {
         name: 'hydrogen:virtual-files',
         configResolved(_config) {
             config = _config;
+            // @ts-ignore
+            config.plugins.push(addPathToConfigProxy());
         },
         configureServer(_server) {
             server = _server;
         },
         resolveId(source, importer) {
             if (source === VIRTUAL_HYDROGEN_CONFIG_ID) {
-                return findHydrogenConfigPath(config.root, pluginOptions.configPath).then((hcPath) => 
-                // This direct dependency on a real file
-                // makes HMR work for the virtual module.
-                this.resolve(hcPath, importer, { skipSelf: true }));
+                return findHydrogenConfigPath(config.root, pluginOptions.configPath).then((hcPath) => {
+                    resolvedConfigPath = hcPath;
+                    // This direct dependency on a real file
+                    // makes HMR work for the virtual module.
+                    return this.resolve(hcPath, importer, { skipSelf: true });
+                });
             }
             if ([
                 VIRTUAL_PROXY_HYDROGEN_CONFIG_ID,
@@ -81,6 +86,18 @@ export default (pluginOptions) => {
         const { loaded } = await viteception([VIRTUAL_PROXY_HYDROGEN_CONFIG_ID]);
         return loaded[0].default;
     }
+    function addPathToConfigProxy() {
+        return {
+            name: 'hydrogen:virtual-files-post',
+            enforce: 'post',
+            transform(code, id) {
+                if (id === '\0' + VIRTUAL_PROXY_HYDROGEN_CONFIG_ID) {
+                    // The CLI needs to import the Hydrogen config path
+                    return (code + ` export const configPath = '${resolvedConfigPath || ''}';`);
+                }
+            },
+        };
+    }
 };
 async function findHydrogenConfigPath(root, userProvidedPath) {
     let configPath = userProvidedPath;

package/dist/esnext/framework/viteception.d.ts

@@ -1,4 +1,5 @@
-export declare function viteception(paths: string[]): Promise<{
+import { InlineConfig } from 'vite';
+export declare function viteception(paths: string[], options?: InlineConfig): Promise<{
     server: import("vite").ViteDevServer;
     loaded: Record<string, any>[];
 }>;

package/dist/esnext/framework/viteception.js

@@ -1,10 +1,11 @@
 import { createServer } from 'vite';
-export async function viteception(paths) {
+export async function viteception(paths, options) {
     const isWorker = process.env.WORKER;
     delete process.env.WORKER;
     const server = await createServer({
         clearScreen: false,
         server: { middlewareMode: 'ssr' },
+        ...options,
     });
     if (isWorker) {
         process.env.WORKER = isWorker;

package/dist/esnext/hooks/useCartLine/useCartLine.d.ts

@@ -7,13 +7,13 @@ export declare function useCartLine(): {
     attributes: ({
         __typename?: "Attribute" | undefined;
     } & Pick<import("../../storefront-api-types").Attribute, "key" | "value">)[];
-    estimatedCost: {
-        __typename?: "CartLineEstimatedCost" | undefined;
+    cost: {
+        __typename?: "CartLineCost" | undefined;
     } & {
         totalAmount: {
             __typename?: "MoneyV2" | undefined;
         } & Pick<import("../../storefront-api-types").MoneyV2, "currencyCode" | "amount">;
-        compareAtAmount?: import("../../storefront-api-types").Maybe<{
+        compareAtAmountPerQuantity?: import("../../storefront-api-types").Maybe<{
             __typename?: "MoneyV2" | undefined;
         } & Pick<import("../../storefront-api-types").MoneyV2, "currencyCode" | "amount">> | undefined;
     };

package/dist/esnext/hooks/useLocalization/useLocalization.d.ts

@@ -0,0 +1,4 @@
+import { type LocalizationContextValue } from '../../components/LocalizationProvider/LocalizationContext.client';
+export declare function useLocalization(): LocalizationContextValue & {
+    locale: string;
+};

package/dist/esnext/hooks/useLocalization/useLocalization.js

@@ -0,0 +1,14 @@
+import { useMemo } from 'react';
+import { LocalizationContext, } from '../../components/LocalizationProvider/LocalizationContext.client';
+import { useEnvContext } from '../../foundation/ssr-interop';
+export function useLocalization() {
+    const localization = useEnvContext((req) => req.ctx.localization, LocalizationContext);
+    if (localization == null) {
+        throw new Error('No Localization Context available');
+    }
+    const localizationValue = useMemo(() => ({
+        ...localization,
+        locale: localization.language.isoCode + '-' + localization.country.isoCode,
+    }), [localization]);
+    return localizationValue;
+}

package/dist/esnext/hooks/useMeasurement/hooks.js

@@ -1,8 +1,8 @@
 import { useMemo } from 'react';
-import { useShop } from '../../foundation';
+import { useLocalization } from '../useLocalization/useLocalization';
 import { getMeasurementAsParts, getMeasurementAsString } from '../../utilities';
 export function useMeasurement(measurement, options = {}) {
-    const { locale } = useShop();
+    const { locale } = useLocalization();
     return useMemo(() => {
         return {
             localizedString: getMeasurementAsString(measurement, locale, options),

package/dist/esnext/hooks/useMoney/hooks.js

@@ -1,12 +1,12 @@
 import { useMemo } from 'react';
-import { useShop } from '../../foundation/useShop';
+import { useLocalization } from '../useLocalization/useLocalization';
 /**
  * The `useMoney` hook takes a [MoneyV2 object](https://shopify.dev/api/storefront/reference/common-objects/moneyv2) and returns a
  * default-formatted string of the amount with the correct currency indicator, along with some of the parts provided by
  * [Intl.NumberFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat).
  */
 export function useMoney(money) {
-    const { locale } = useShop();
+    const { locale } = useLocalization();
     const amount = parseFloat(money.amount);
     const options = useMemo(() => ({
         style: 'currency',

package/dist/esnext/index.d.ts

@@ -25,6 +25,7 @@ export { useServerAnalytics } from './foundation/Analytics/hook';
 export { ShopifyAnalytics } from './foundation/Analytics/connectors/Shopify/ShopifyAnalytics.server';
 export { ShopifyAnalyticsConstants } from './foundation/Analytics/connectors/Shopify/const';
 export { useSession } from './foundation/useSession/useSession';
+export { useLocalization } from './hooks/useLocalization/useLocalization';
 export { Cookie } from './foundation/Cookie/Cookie';
 /**
  * Export server-only CartQuery here instead of `CartProvider.client` to prevent
@@ -37,3 +38,5 @@ export { CartQuery } from './components/CartProvider/cart-queries';
 export { fetchSync } from './foundation/fetchSync/server/fetchSync';
 export { type HydrogenRequest } from './foundation/HydrogenRequest/HydrogenRequest.server';
 export { type HydrogenResponse } from './foundation/HydrogenResponse/HydrogenResponse.server';
+export { type HydrogenRouteProps } from './types';
+export { type ResourceGetter as HydrogenApiRoute, RequestOptions as HydrogenApiRouteOptions, } from './utilities/apiRoutes';

package/dist/esnext/index.js

@@ -25,6 +25,7 @@ export { useServerAnalytics } from './foundation/Analytics/hook';
 export { ShopifyAnalytics } from './foundation/Analytics/connectors/Shopify/ShopifyAnalytics.server';
 export { ShopifyAnalyticsConstants } from './foundation/Analytics/connectors/Shopify/const';
 export { useSession } from './foundation/useSession/useSession';
+export { useLocalization } from './hooks/useLocalization/useLocalization';
 export { Cookie } from './foundation/Cookie/Cookie';
 /**
  * Export server-only CartQuery here instead of `CartProvider.client` to prevent

package/dist/esnext/platforms/node.d.ts

@@ -3,7 +3,7 @@ import connect from 'connect';
 declare type CreateServerOptions = {
     cache?: Cache;
 };
-export declare function createServer({ cache }?: CreateServerOptions): Promise<{
+export declare function createServer({ cache, }?: CreateServerOptions): Promise<{
     app: connect.Server;
 }>;
 export {};

package/dist/esnext/platforms/node.js

@@ -13,8 +13,9 @@ import serveStatic from 'serve-static';
 import compression from 'compression';
 import bodyParser from 'body-parser';
 import connect from 'connect';
+import { InMemoryCache } from '../framework/cache/in-memory';
 const handleRequest = entrypoint;
-export async function createServer({ cache } = {}) {
+export async function createServer({ cache = new InMemoryCache(), } = {}) {
     // @ts-ignore
     globalThis.Oxygen = { env: process.env };
     const app = connect();

package/dist/esnext/storefront-api-types.d.ts

@@ -401,22 +401,31 @@ export declare enum CardBrand {
 /** A cart represents the merchandise that a buyer intends to purchase, and the estimated cost associated with the cart. To learn how to interact with a cart during a customer's session, refer to [Manage a cart with the Storefront API](https://shopify.dev/api/examples/cart). */
 export declare type Cart = Node & {
     __typename?: 'Cart';
+    /** An attribute associated with the cart. */
+    attribute?: Maybe<Attribute>;
     /** The attributes associated with the cart. Attributes are represented as key-value pairs. */
     attributes: Array<Attribute>;
     /** Information about the buyer that is interacting with the cart. */
     buyerIdentity: CartBuyerIdentity;
     /** The URL of the checkout for the cart. */
     checkoutUrl: Scalars['URL'];
+    /** The estimated costs that the buyer will pay at checkout. The costs are subject to change and changes will be reflected at checkout. The `cost` field uses the `buyerIdentity` field to determine [international pricing](https://shopify.dev/api/examples/international-pricing#create-a-cart). */
+    cost: CartCost;
     /** The date and time when the cart was created. */
     createdAt: Scalars['DateTime'];
     /** The delivery groups available for the cart, based on the default address of the logged-in customer. */
     deliveryGroups: CartDeliveryGroupConnection;
+    /** The discounts that have been applied to the entire cart. */
+    discountAllocations: Array<CartAutomaticDiscountAllocation | CartCodeDiscountAllocation | CartCustomDiscountAllocation>;
     /**
      * The case-insensitive discount codes that the customer added at checkout.
      *
      */
     discountCodes: Array<CartDiscountCode>;
-    /** The estimated costs that the buyer will pay at checkout. The estimated costs are subject to change and changes will be reflected at checkout. The `estimatedCost` field uses the `buyerIdentity` field to determine [international pricing](https://shopify.dev/api/examples/international-pricing#create-a-cart). */
+    /**
+     * The estimated costs that the buyer will pay at checkout. The estimated costs are subject to change and changes will be reflected at checkout. The `estimatedCost` field uses the `buyerIdentity` field to determine [international pricing](https://shopify.dev/api/examples/international-pricing#create-a-cart).
+     * @deprecated Use `cost` instead
+     */
     estimatedCost: CartEstimatedCost;
     /** A globally-unique identifier. */
     id: Scalars['ID'];
@@ -430,6 +439,10 @@ export declare type Cart = Node & {
     updatedAt: Scalars['DateTime'];
 };
 /** A cart represents the merchandise that a buyer intends to purchase, and the estimated cost associated with the cart. To learn how to interact with a cart during a customer's session, refer to [Manage a cart with the Storefront API](https://shopify.dev/api/examples/cart). */
+export declare type CartAttributeArgs = {
+    key: Scalars['String'];
+};
+/** A cart represents the merchandise that a buyer intends to purchase, and the estimated cost associated with the cart. To learn how to interact with a cart during a customer's session, refer to [Manage a cart with the Storefront API](https://shopify.dev/api/examples/cart). */
 export declare type CartDeliveryGroupsArgs = {
     after?: InputMaybe<Scalars['String']>;
     before?: InputMaybe<Scalars['String']>;
@@ -506,6 +519,33 @@ export declare type CartCodeDiscountAllocation = CartDiscountAllocation & {
     /** The discounted amount that has been applied to the cart line. */
     discountedAmount: MoneyV2;
 };
+/**
+ * The costs that the buyer will pay at checkout.
+ * It uses [`CartBuyerIdentity`](https://shopify.dev/api/storefront/reference/cart/cartbuyeridentity) to determine
+ * [international pricing](https://shopify.dev/api/examples/international-pricing#create-a-cart).
+ *
+ */
+export declare type CartCost = {
+    __typename?: 'CartCost';
+    /** The estimated amount, before taxes and discounts, for the customer to pay at checkout. The checkout charge amount doesn't include any deferred payments that'll be paid at a later date. If the cart has no deferred payments, the checkout charge amount is equivalent to subtotalAmount. */
+    checkoutChargeAmount: MoneyV2;
+    /** The amount, before taxes and cart-level discounts, for the customer to pay. */
+    subtotalAmount: MoneyV2;
+    /** Whether or not the subtotal amount is estimated. */
+    subtotalAmountEstimated: Scalars['Boolean'];
+    /** The total amount for the customer to pay. */
+    totalAmount: MoneyV2;
+    /** Whether or not the total amount is estimated. */
+    totalAmountEstimated: Scalars['Boolean'];
+    /** The duty amount for the customer to pay at checkout. */
+    totalDutyAmount?: Maybe<MoneyV2>;
+    /** Whether or not the total duty amount is estimated. */
+    totalDutyAmountEstimated: Scalars['Boolean'];
+    /** The tax amount for the customer to pay at checkout. */
+    totalTaxAmount?: Maybe<MoneyV2>;
+    /** Whether or not the total tax amount is estimated. */
+    totalTaxAmountEstimated: Scalars['Boolean'];
+};
 /** Return type for `cartCreate` mutation. */
 export declare type CartCreatePayload = {
     __typename?: 'CartCreatePayload';
@@ -514,6 +554,14 @@ export declare type CartCreatePayload = {
     /** The list of errors that occurred from executing the mutation. */
     userErrors: Array<CartUserError>;
 };
+/** The discounts automatically applied to the cart line based on prerequisites that have been met. */
+export declare type CartCustomDiscountAllocation = CartDiscountAllocation & {
+    __typename?: 'CartCustomDiscountAllocation';
+    /** The discounted amount that has been applied to the cart line. */
+    discountedAmount: MoneyV2;
+    /** The title of the allocated discount. */
+    title: Scalars['String'];
+};
 /** Information about the options available for one or more line items to be delivered to a specific address. */
 export declare type CartDeliveryGroup = {
     __typename?: 'CartDeliveryGroup';
@@ -614,6 +662,8 @@ export declare enum CartErrorCode {
  */
 export declare type CartEstimatedCost = {
     __typename?: 'CartEstimatedCost';
+    /** The estimated amount, before taxes and discounts, for the customer to pay at checkout. The checkout charge amount doesn't include any deferred payments that'll be paid at a later date. If the cart has no deferred payments, the checkout charge amount is equivalent to subtotalAmount. */
+    checkoutChargeAmount: MoneyV2;
     /** The estimated amount, before taxes and discounts, for the customer to pay. */
     subtotalAmount: MoneyV2;
     /** The estimated total amount for the customer to pay. */
@@ -642,11 +692,18 @@ export declare type CartInput = {
 /** Represents information about the merchandise in the cart. */
 export declare type CartLine = Node & {
     __typename?: 'CartLine';
+    /** An attribute associated with the cart line. */
+    attribute?: Maybe<Attribute>;
     /** The attributes associated with the cart line. Attributes are represented as key-value pairs. */
     attributes: Array<Attribute>;
+    /** The cost of the merchandise that the buyer will pay for at checkout. The costs are subject to change and changes will be reflected at checkout. */
+    cost: CartLineCost;
     /** The discounts that have been applied to the cart line. */
-    discountAllocations: Array<CartAutomaticDiscountAllocation | CartCodeDiscountAllocation>;
-    /** The estimated cost of the merchandise that the buyer will pay for at checkout. The estimated costs are subject to change and changes will be reflected at checkout. */
+    discountAllocations: Array<CartAutomaticDiscountAllocation | CartCodeDiscountAllocation | CartCustomDiscountAllocation>;
+    /**
+     * The estimated cost of the merchandise that the buyer will pay for at checkout. The estimated costs are subject to change and changes will be reflected at checkout.
+     * @deprecated Use `cost` instead
+     */
     estimatedCost: CartLineEstimatedCost;
     /** A globally-unique identifier. */
     id: Scalars['ID'];
@@ -657,6 +714,10 @@ export declare type CartLine = Node & {
     /** The selling plan associated with the cart line and the effect that each selling plan has on variants when they're purchased. */
     sellingPlanAllocation?: Maybe<SellingPlanAllocation>;
 };
+/** Represents information about the merchandise in the cart. */
+export declare type CartLineAttributeArgs = {
+    key: Scalars['String'];
+};
 /**
  * An auto-generated type for paginating through multiple CartLines.
  *
@@ -670,6 +731,18 @@ export declare type CartLineConnection = {
     /** Information to aid in pagination. */
     pageInfo: PageInfo;
 };
+/** The cost of the merchandise line that the buyer will pay at checkout. */
+export declare type CartLineCost = {
+    __typename?: 'CartLineCost';
+    /** The amount of the merchandise line. */
+    amountPerQuantity: MoneyV2;
+    /** The compare at amount of the merchandise line. */
+    compareAtAmountPerQuantity?: Maybe<MoneyV2>;
+    /** The cost of the merchandise line before line-level discounts. */
+    subtotalAmount: MoneyV2;
+    /** The total cost of the merchandise line. */
+    totalAmount: MoneyV2;
+};
 /**
  * An auto-generated type which holds one CartLine and a cursor during pagination.
  *
@@ -5457,6 +5530,8 @@ export declare type SelectedOptionInput = {
 /** Represents how products and variants can be sold and purchased. */
 export declare type SellingPlan = {
     __typename?: 'SellingPlan';
+    /** The initial payment due for the purchase. */
+    checkoutCharge: SellingPlanCheckoutCharge;
     /** The description of the selling plan. */
     description?: Maybe<Scalars['String']>;
     /** A globally-unique identifier. */
@@ -5473,8 +5548,12 @@ export declare type SellingPlan = {
 /** Represents an association between a variant and a selling plan. Selling plan allocations describe the options offered for each variant, and the price of the variant when purchased with a selling plan. */
 export declare type SellingPlanAllocation = {
     __typename?: 'SellingPlanAllocation';
+    /** The checkout charge amount due for the purchase. */
+    checkoutChargeAmount: MoneyV2;
     /** A list of price adjustments, with a maximum of two. When there are two, the first price adjustment goes into effect at the time of purchase, while the second one starts after a certain number of orders. A price adjustment represents how a selling plan affects pricing when a variant is purchased with a selling plan. Prices display in the customer's currency if the shop is configured for it. */
     priceAdjustments: Array<SellingPlanAllocationPriceAdjustment>;
+    /** The remaining balance charge amount due for the purchase. */
+    remainingBalanceChargeAmount: MoneyV2;
     /** A representation of how products and variants can be sold and purchased. For example, an individual selling plan could be '6 weeks of prepaid granola, delivered weekly'. */
     sellingPlan: SellingPlan;
 };
@@ -5514,6 +5593,29 @@ export declare type SellingPlanAllocationPriceAdjustment = {
     /** The resulting price per unit for the variant associated with the selling plan. If the variant isn't sold by quantity or measurement, then this field returns `null`. */
     unitPrice?: Maybe<MoneyV2>;
 };
+/** The initial payment due for the purchase. */
+export declare type SellingPlanCheckoutCharge = {
+    __typename?: 'SellingPlanCheckoutCharge';
+    /** The charge type for the checkout charge. */
+    type: SellingPlanCheckoutChargeType;
+    /** The charge value for the checkout charge. */
+    value: SellingPlanCheckoutChargeValue;
+};
+/** The percentage value of the price used for checkout charge. */
+export declare type SellingPlanCheckoutChargePercentageValue = {
+    __typename?: 'SellingPlanCheckoutChargePercentageValue';
+    /** The percentage value of the price used for checkout charge. */
+    percentage: Scalars['Float'];
+};
+/** The checkout charge when the full amount isn't charged at checkout. */
+export declare enum SellingPlanCheckoutChargeType {
+    /** The checkout charge is a percentage of the product or variant price. */
+    Percentage = "PERCENTAGE",
+    /** The checkout charge is a fixed price amount. */
+    Price = "PRICE"
+}
+/** The portion of the price to be charged at checkout. */
+export declare type SellingPlanCheckoutChargeValue = MoneyV2 | SellingPlanCheckoutChargePercentageValue;
 /**
  * An auto-generated type for paginating through multiple SellingPlans.
  *

package/dist/esnext/storefront-api-types.js

@@ -1673,6 +1673,14 @@ export var ProductVariantSortKeys;
     /** Sort by the `title` value. */
     ProductVariantSortKeys["Title"] = "TITLE";
 })(ProductVariantSortKeys || (ProductVariantSortKeys = {}));
+/** The checkout charge when the full amount isn't charged at checkout. */
+export var SellingPlanCheckoutChargeType;
+(function (SellingPlanCheckoutChargeType) {
+    /** The checkout charge is a percentage of the product or variant price. */
+    SellingPlanCheckoutChargeType["Percentage"] = "PERCENTAGE";
+    /** The checkout charge is a fixed price amount. */
+    SellingPlanCheckoutChargeType["Price"] = "PRICE";
+})(SellingPlanCheckoutChargeType || (SellingPlanCheckoutChargeType = {}));
 /** The different kinds of order transactions. */
 export var TransactionKind;
 (function (TransactionKind) {

package/dist/esnext/types.d.ts

@@ -62,6 +62,7 @@ export declare type InlineHydrogenConfig = ClientConfig & {
     serverAnalyticsConnectors?: Array<ServerAnalyticsConnector>;
     logger?: LoggerConfig;
     session?: (log: Logger) => SessionStorageAdapter;
+    poweredByHeader?: boolean;
     __EXPERIMENTAL__devTools?: boolean;
 };
 export declare type ResolvedHydrogenConfig = Omit<InlineHydrogenConfig, 'routes'> & {
@@ -103,3 +104,12 @@ export interface AllCacheOptions {
 }
 export declare type CachingStrategy = AllCacheOptions;
 export declare type PreloadOptions = boolean | string;
+export declare type HydrogenRouteProps = {
+    request: HydrogenRequest;
+    response: HydrogenResponse;
+    log: Logger;
+    params: Record<string, any>;
+    pathname: string;
+    search: string;
+    [key: string]: any;
+};

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

@@ -1,14 +1,15 @@
 import { ResolvedHydrogenConfig, ResolvedHydrogenRoutes } from '../types';
 import type { HydrogenRequest } from '../foundation/HydrogenRequest/HydrogenRequest.server';
 import { SessionApi, SessionStorageAdapter } from '../foundation/session/session';
+import { UseShopQueryResponse } from '../hooks/useShopQuery/hooks';
 declare type RouteParams = Record<string, string>;
-declare type RequestOptions = {
+export declare type RequestOptions = {
     params: RouteParams;
-    queryShop: (args: QueryShopArgs) => Promise<any>;
+    queryShop: <T>(args: QueryShopArgs) => Promise<UseShopQueryResponse<T>>;
     session: SessionApi | null;
     hydrogenConfig: ResolvedHydrogenConfig;
 };
-export declare type ResourceGetter = (request: Request, requestOptions: RequestOptions) => Promise<Response | Object | String>;
+export declare type ResourceGetter = (request: HydrogenRequest, requestOptions: RequestOptions) => Promise<Response | Object | String>;
 interface HydrogenApiRoute {
     path: string;
     resource: ResourceGetter;

package/dist/esnext/utilities/log/log-cache-api-status.js

@@ -9,6 +9,9 @@ export function logCacheApiStatus(status, url) {
     if (url.includes('shopify.dev')) {
         url = decodeURIComponent(url);
         queryName = findQueryName(url);
+        if (url.includes('?lock')) {
+            queryName += '-lock';
+        }
     }
     log.debug(gray(`[Cache] ${status?.padEnd(8)} ${queryName ? `query ${queryName}` : url}`));
 }

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

@@ -2,3 +2,4 @@ export declare function getStorefrontApiRequestHeaders({ buyerIp, storefrontToke
     buyerIp?: string | null;
     storefrontToken: string;
 }): Record<string, any>;
+export declare function getOxygenVariable(key: string): any;

package/dist/esnext/utilities/storefrontApi.js

@@ -21,6 +21,6 @@ export function getStorefrontApiRequestHeaders({ buyerIp, storefrontToken, }) {
     }
     return headers;
 }
-function getOxygenVariable(key) {
+export function getOxygenVariable(key) {
     return typeof Oxygen !== 'undefined' ? Oxygen?.env?.[key] : null;
 }

package/dist/esnext/version.d.ts

@@ -1 +1 @@
-export declare const LIB_VERSION = "0.25.1";
+export declare const LIB_VERSION = "0.26.0";

package/dist/esnext/version.js

@@ -1 +1 @@
-export const LIB_VERSION = '0.25.1';
+export const LIB_VERSION = '0.26.0';

package/dist/node/framework/cache/in-memory.d.ts

@@ -1,12 +1,17 @@
 /**
- * This is an in-memory implementation of `Cache` that *barely*
- * works and is only meant to be used during development.
+ * This is a limited implementation of an in-memory cache.
+ * It only supports the `cache-control` header.
+ * It does NOT support `age` or `expires` headers.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Cache
  */
-export declare class InMemoryCache {
-    private store;
+export declare class InMemoryCache implements Cache {
+    #private;
     constructor();
-    put(request: Request, response: Response): void;
-    match(request: Request): Response | undefined;
-    delete(request: Request): void;
+    add(request: RequestInfo): Promise<void>;
+    addAll(requests: RequestInfo[]): Promise<void>;
+    matchAll(request?: RequestInfo, options?: CacheQueryOptions): Promise<readonly Response[]>;
+    put(request: Request, response: Response): Promise<void>;
+    match(request: Request): Promise<Response | undefined>;
+    delete(request: Request): Promise<boolean>;
     keys(request?: Request): Promise<Request[]>;
 }

package/dist/node/framework/cache/in-memory.js

@@ -2,50 +2,78 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryCache = void 0;
 /**
- * This is an in-memory implementation of `Cache` that *barely*
- * works and is only meant to be used during development.
+ * This is a limited implementation of an in-memory cache.
+ * It only supports the `cache-control` header.
+ * It does NOT support `age` or `expires` headers.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Cache
  */
 class InMemoryCache {
-    store;
+    #store;
     constructor() {
-        this.store = new Map();
+        this.#store = new Map();
     }
-    put(request, response) {
-        this.store.set(request.url, {
-            value: response,
-            date: new Date(),
+    add(request) {
+        throw new Error('Method not implemented. Use `put` instead.');
+    }
+    addAll(requests) {
+        throw new Error('Method not implemented. Use `put` instead.');
+    }
+    matchAll(request, options) {
+        throw new Error('Method not implemented. Use `match` instead.');
+    }
+    async put(request, response) {
+        if (request.method !== 'GET') {
+            throw new TypeError('Cannot cache response to non-GET request.');
+        }
+        if (response.status === 206) {
+            throw new TypeError('Cannot cache response to a range request (206 Partial Content).');
+        }
+        if (response.headers.get('vary')?.includes('*')) {
+            throw new TypeError("Cannot cache response with 'Vary: *' header.");
+        }
+        this.#store.set(request.url, {
+            body: new Uint8Array(await response.arrayBuffer()),
+            status: response.status,
+            headers: [...response.headers],
+            timestamp: Date.now(),
         });
     }
-    match(request) {
-        const match = this.store.get(request.url);
+    async match(request) {
+        if (request.method !== 'GET')
+            return;
+        const match = this.#store.get(request.url);
         if (!match) {
             return;
         }
-        const { value, date } = match;
-        const cacheControl = value.headers.get('cache-control') || '';
+        const { body, timestamp, ...metadata } = match;
+        const headers = new Headers(metadata.headers);
+        const cacheControl = headers.get('cache-control') || '';
         const maxAge = parseInt(cacheControl.match(/max-age=(\d+)/)?.[1] || '0', 10);
         const swr = parseInt(cacheControl.match(/stale-while-revalidate=(\d+)/)?.[1] || '0', 10);
-        const age = (new Date().valueOf() - date.valueOf()) / 1000;
+        const age = (Date.now() - timestamp) / 1000;
         const isMiss = age > maxAge + swr;
         if (isMiss) {
-            this.store.delete(request.url);
+            this.#store.delete(request.url);
             return;
         }
         const isStale = age > maxAge;
-        const headers = new Headers(value.headers);
         headers.set('cache', isStale ? 'STALE' : 'HIT');
-        headers.set('date', date.toUTCString());
-        const response = new Response(value.body, {
+        headers.set('date', new Date(timestamp).toUTCString());
+        return new Response(body, {
+            status: metadata.status ?? 200,
             headers,
         });
-        return response;
     }
-    delete(request) {
-        this.store.delete(request.url);
+    async delete(request) {
+        if (this.#store.has(request.url)) {
+            this.#store.delete(request.url);
+            return true;
+        }
+        return false;
     }
     keys(request) {
         const cacheKeys = [];
-        for (const url of this.store.keys()) {
+        for (const url of this.#store.keys()) {
             if (!request || request.url === url) {
                 cacheKeys.push(new Request(url));
             }

package/dist/node/framework/load-config.d.ts

@@ -0,0 +1,6 @@
+export declare function loadConfig(options?: {
+    root: string;
+}): Promise<{
+    configuration: any;
+    configurationPath: any;
+}>;

package/dist/node/framework/load-config.js

@@ -0,0 +1,14 @@
+"use strict";
+// Provide Hydrogen config loader to external tools like the CLI
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = void 0;
+const vite_plugin_hydrogen_virtual_files_1 = require("./plugins/vite-plugin-hydrogen-virtual-files");
+const viteception_1 = require("./viteception");
+async function loadConfig(options = { root: process.cwd() }) {
+    const { loaded } = await (0, viteception_1.viteception)([vite_plugin_hydrogen_virtual_files_1.VIRTUAL_PROXY_HYDROGEN_CONFIG_ID], options);
+    return {
+        configuration: loaded[0].default,
+        configurationPath: loaded[0].configPath,
+    };
+}
+exports.loadConfig = loadConfig;