fontdue-js 2.28.0 → 3.0.0-alpha10

package/dist/__tests__/nextAdapter.test.js

@@ -0,0 +1,447 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+// The next adapter modules read process.env at module load, so each test
+// group stubs the env and re-imports them fresh.
+async function importTenant() {
+  return await import("../next/tenant.js");
+}
+async function importConfig() {
+  return await import("../next/config.js");
+}
+async function importRevalidate() {
+  return await import("../next/revalidate.js");
+}
+const revalidateTag = vi.fn();
+vi.mock('next/cache', () => ({
+  revalidateTag: tag => revalidateTag(tag)
+}));
+
+// Next's notFound() throws a sentinel the framework catches; the mock does
+// the same so tests can assert on it.
+vi.mock('next/navigation', () => ({
+  notFound: () => {
+    throw new Error('NEXT_NOT_FOUND');
+  }
+}));
+beforeEach(() => {
+  vi.resetModules();
+  revalidateTag.mockClear();
+  vi.unstubAllEnvs();
+  vi.restoreAllMocks();
+});
+function stubSingleTenant() {
+  let url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'https://acme.fontdue.com';
+  vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', url);
+  vi.stubEnv('FONTDUE_MULTI_TENANT', '');
+  vi.stubEnv('FONTDUE_ORIGIN', '');
+  vi.stubEnv('FONTDUE_PROXY_SECRET', '');
+}
+function stubMultiTenant() {
+  let {
+    origin = '',
+    secret = ''
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', '');
+  vi.stubEnv('FONTDUE_MULTI_TENANT', '1');
+  vi.stubEnv('FONTDUE_ORIGIN', origin);
+  vi.stubEnv('FONTDUE_PROXY_SECRET', secret);
+}
+describe('isValidDomain', () => {
+  it('accepts plain dotted hostnames and rejects everything else', async () => {
+    stubMultiTenant();
+    const {
+      isValidDomain
+    } = await importTenant();
+    expect(isValidDomain('acme.fontdue.com')).toBe(true);
+    expect(isValidDomain('a-b.example')).toBe(true);
+    expect(isValidDomain('localhost')).toBe(false); // no dot
+    expect(isValidDomain('acme.fontdue.com:3000')).toBe(false); // port
+    expect(isValidDomain('acme.fontdue.com/x')).toBe(false); // path
+    expect(isValidDomain('-bad.example')).toBe(false);
+    expect(isValidDomain('a'.repeat(254) + '.example')).toBe(false);
+  });
+});
+describe('fontdueEndpoint', () => {
+  it('single-tenant: targets NEXT_PUBLIC_FONTDUE_URL with no headers', async () => {
+    stubSingleTenant('https://acme.fontdue.com');
+    const {
+      fontdueEndpoint
+    } = await importTenant();
+    expect(fontdueEndpoint('acme.fontdue.com')).toEqual({
+      domain: 'acme.fontdue.com',
+      origin: 'https://acme.fontdue.com',
+      headers: {},
+      tags: ['graphql', 'graphql:acme.fontdue.com']
+    });
+  });
+  it('single-tenant: throws when NEXT_PUBLIC_FONTDUE_URL is missing', async () => {
+    vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', '');
+    vi.stubEnv('FONTDUE_MULTI_TENANT', '');
+    const {
+      fontdueEndpoint
+    } = await importTenant();
+    expect(() => fontdueEndpoint('acme.fontdue.com')).toThrow(/NEXT_PUBLIC_FONTDUE_URL/);
+  });
+  it('multi-tenant: forwards the host to FONTDUE_ORIGIN with the proxy secret', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000',
+      secret: 's3cret'
+    });
+    const {
+      fontdueEndpoint
+    } = await importTenant();
+    expect(fontdueEndpoint('acme.fontdue.com')).toEqual({
+      domain: 'acme.fontdue.com',
+      origin: 'http://app:4000',
+      headers: {
+        'x-forwarded-host': 'acme.fontdue.com',
+        'x-fontdue-proxy-secret': 's3cret'
+      },
+      tags: ['graphql', 'graphql:acme.fontdue.com']
+    });
+  });
+  it('multi-tenant: omits the secret header when unset', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    const {
+      fontdueEndpoint
+    } = await importTenant();
+    expect(fontdueEndpoint('acme.fontdue.com').headers).toEqual({
+      'x-forwarded-host': 'acme.fontdue.com'
+    });
+  });
+  it('multi-tenant: falls back to the tenant public URL without FONTDUE_ORIGIN', async () => {
+    stubMultiTenant();
+    const {
+      fontdueEndpoint
+    } = await importTenant();
+    expect(fontdueEndpoint('acme.fontdue.com').origin).toBe('https://acme.fontdue.com');
+  });
+});
+describe('configureFontdueRender', () => {
+  it('rejects invalid domains with null and sets no config', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    const {
+      configureFontdueRender
+    } = await importTenant();
+    const {
+      getFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    expect(configureFontdueRender('not a domain')).toBeNull();
+    expect(getFontdueServerConfig()).toBeUndefined();
+  });
+  it('sets the per-render server config and returns the endpoint', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000',
+      secret: 's3cret'
+    });
+    const {
+      configureFontdueRender
+    } = await importTenant();
+    const {
+      getFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    const endpoint = configureFontdueRender('acme.fontdue.com');
+    expect(endpoint === null || endpoint === void 0 ? void 0 : endpoint.origin).toBe('http://app:4000');
+    // Outside an RSC render React.cache doesn't memoize, so the write is a
+    // no-op here — but the config passed must still be shaped correctly, so
+    // assert via fontdueServerConfig instead.
+    const {
+      fontdueServerConfig
+    } = await importTenant();
+    expect(fontdueServerConfig('acme.fontdue.com')).toEqual({
+      url: 'http://app:4000',
+      headers: {
+        'x-forwarded-host': 'acme.fontdue.com',
+        'x-fontdue-proxy-secret': 's3cret'
+      },
+      cacheTags: ['graphql:acme.fontdue.com'],
+      domain: 'acme.fontdue.com'
+    });
+  });
+});
+describe('prepareFontdueRender', () => {
+  const props = params => ({
+    params: Promise.resolve(params)
+  });
+  it('configures the render and returns the endpoint', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    const {
+      prepareFontdueRender
+    } = await importTenant();
+    const endpoint = await prepareFontdueRender(props({
+      domain: 'acme.fontdue.com',
+      slug: 'sans'
+    }));
+    expect(endpoint.origin).toBe('http://app:4000');
+    expect(endpoint.tags).toContain('graphql:acme.fontdue.com');
+  });
+  it('404s invalid or missing domains', async () => {
+    stubMultiTenant();
+    const {
+      prepareFontdueRender
+    } = await importTenant();
+    await expect(prepareFontdueRender(props({
+      domain: 'not a domain'
+    }))).rejects.toThrow('NEXT_NOT_FOUND');
+    await expect(prepareFontdueRender(props({
+      slug: 'sans'
+    }))).rejects.toThrow('NEXT_NOT_FOUND');
+  });
+});
+describe('currentFontdueEndpoint', () => {
+  it('multi-tenant: throws when no render config was set', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    const {
+      currentFontdueEndpoint
+    } = await importTenant();
+    expect(() => currentFontdueEndpoint()).toThrow(/prepareFontdueRender/);
+  });
+  it('single-tenant: derives the endpoint from NEXT_PUBLIC_FONTDUE_URL', async () => {
+    stubSingleTenant('https://acme.fontdue.com');
+    const {
+      currentFontdueEndpoint
+    } = await importTenant();
+    expect(currentFontdueEndpoint()).toEqual({
+      domain: 'acme.fontdue.com',
+      origin: 'https://acme.fontdue.com',
+      headers: {},
+      tags: ['graphql', 'graphql:acme.fontdue.com']
+    });
+  });
+  it('uses the render-configured domain when set', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    vi.doMock('../relay/serverConfig', async importActual => ({
+      ...(await importActual()),
+      getFontdueServerConfig: () => ({
+        domain: 'acme.fontdue.com'
+      })
+    }));
+    const {
+      currentFontdueEndpoint
+    } = await importTenant();
+    expect(currentFontdueEndpoint().headers['x-forwarded-host']).toBe('acme.fontdue.com');
+    vi.doUnmock('../relay/serverConfig');
+  });
+});
+describe('generateStaticParams', () => {
+  it('returns no build-time params (everything renders on demand)', async () => {
+    stubMultiTenant();
+    const {
+      generateStaticParams
+    } = await importTenant();
+    await expect(generateStaticParams()).resolves.toEqual([]);
+  });
+});
+
+// withFontdue detects the route-tree shape from the working directory; give
+// it one with or without src/app/[domain].
+function mockAppDir(_ref) {
+  let {
+    domainTree
+  } = _ref;
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'fontdue-app-'));
+  fs.mkdirSync(path.join(dir, domainTree ? 'src/app/[domain]' : 'src/app'), {
+    recursive: true
+  });
+  vi.spyOn(process, 'cwd').mockReturnValue(dir);
+}
+describe('withFontdue', () => {
+  beforeEach(() => mockAppDir({
+    domainTree: true
+  }));
+  it('throws when neither mode is configured', async () => {
+    vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', '');
+    vi.stubEnv('FONTDUE_MULTI_TENANT', '');
+    const {
+      withFontdue
+    } = await importConfig();
+    expect(() => withFontdue({})).toThrow(/NEXT_PUBLIC_FONTDUE_URL/);
+  });
+  it('single-tenant: rewrites every path under the constant domain', async () => {
+    stubSingleTenant('https://acme.fontdue.com');
+    const {
+      withFontdue
+    } = await importConfig();
+    const rewrites = await withFontdue({}).rewrites();
+    expect(rewrites.afterFiles).toEqual([]);
+    expect(rewrites.fallback).toEqual([]);
+    const destinations = rewrites.beforeFiles.map(r => r.destination);
+    expect(destinations).toEqual(['/acme.fontdue.com', '/acme.fontdue.com/robots.txt', '/acme.fontdue.com/sitemap.xml', '/acme.fontdue.com/:path']);
+  });
+  it('multi-tenant: emits forwarded-host rules before host rules, mutually exclusive', async () => {
+    stubMultiTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    const rewrites = await withFontdue({}).rewrites();
+    expect(rewrites.beforeFiles).toHaveLength(8);
+    const [forwarded, hostBased] = [rewrites.beforeFiles.slice(0, 4), rewrites.beforeFiles.slice(4)];
+    for (const rule of forwarded) {
+      var _rule$has;
+      expect((_rule$has = rule.has) === null || _rule$has === void 0 ? void 0 : _rule$has[0]).toMatchObject({
+        type: 'header',
+        key: 'x-forwarded-host'
+      });
+      expect(rule.missing).toBeUndefined();
+    }
+    for (const rule of hostBased) {
+      var _rule$has2, _rule$missing;
+      expect((_rule$has2 = rule.has) === null || _rule$has2 === void 0 ? void 0 : _rule$has2[0]).toMatchObject({
+        type: 'host'
+      });
+      expect((_rule$missing = rule.missing) === null || _rule$missing === void 0 ? void 0 : _rule$missing[0]).toMatchObject({
+        type: 'header',
+        key: 'x-forwarded-host'
+      });
+    }
+  });
+  it("chains the app's beforeFiles rules ahead of the tenant rules", async () => {
+    stubSingleTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    const userRule = {
+      source: '/old',
+      destination: '/new'
+    };
+    const config = withFontdue({
+      rewrites: async () => ({
+        beforeFiles: [userRule]
+      })
+    });
+    const rewrites = await config.rewrites();
+    expect(rewrites.beforeFiles[0]).toEqual(userRule);
+    expect(rewrites.beforeFiles).toHaveLength(5);
+  });
+  it("treats a plain-array rewrites() result as afterFiles, per Next's contract", async () => {
+    stubSingleTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    const userRule = {
+      source: '/old',
+      destination: '/new'
+    };
+    const rewrites = await withFontdue({
+      rewrites: async () => [userRule]
+    }).rewrites();
+    expect(rewrites.afterFiles).toEqual([userRule]);
+    expect(rewrites.beforeFiles).toHaveLength(4);
+  });
+  it('merges image settings, keeping app remotePatterns and overrides', async () => {
+    stubMultiTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    const config = withFontdue({
+      images: {
+        dangerouslyAllowSVG: false,
+        remotePatterns: [{
+          protocol: 'https',
+          hostname: 'cdn.example'
+        }]
+      }
+    });
+    expect(config.images.dangerouslyAllowSVG).toBe(false);
+    // NODE_ENV is 'test' here, i.e. not production → dev workaround active.
+    expect(config.images.unoptimized).toBe(true);
+    const hostnames = config.images.remotePatterns.map(p => p.hostname);
+    expect(hostnames).toContain('cdn.example');
+    expect(hostnames).toContain('*.fontdue.com');
+    expect(hostnames).toContain('**');
+  });
+  it('passes unrelated config through and defaults htmlLimitedBots', async () => {
+    stubSingleTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    const config = withFontdue({
+      reactStrictMode: true
+    });
+    expect(config.reactStrictMode).toBe(true);
+    expect(config.htmlLimitedBots).toEqual(/.*/);
+    expect(withFontdue({
+      htmlLimitedBots: /Googlebot/
+    }).htmlLimitedBots).toEqual(/Googlebot/);
+  });
+  it('single-tenant flat tree: installs no tenant rewrites', async () => {
+    mockAppDir({
+      domainTree: false
+    });
+    stubSingleTenant('https://acme.fontdue.com');
+    const {
+      withFontdue
+    } = await importConfig();
+    const userRule = {
+      source: '/old',
+      destination: '/new'
+    };
+    const rewrites = await withFontdue({
+      rewrites: async () => ({
+        beforeFiles: [userRule]
+      })
+    }).rewrites();
+    expect(rewrites.beforeFiles).toEqual([userRule]);
+    expect(rewrites.afterFiles).toEqual([]);
+  });
+  it('multi-tenant flat tree: refuses to start', async () => {
+    mockAppDir({
+      domainTree: false
+    });
+    stubMultiTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    expect(() => withFontdue({})).toThrow(/\[domain\]/);
+  });
+});
+describe('revalidate POST', () => {
+  it('multi-tenant: purges only the tenant tag', async () => {
+    stubMultiTenant();
+    const {
+      POST
+    } = await importRevalidate();
+    const response = await POST(new Request('http://internal/api/revalidate?domain=Acme.Fontdue.com', {
+      method: 'POST'
+    }));
+    expect(response.status).toBe(200);
+    expect(revalidateTag).toHaveBeenCalledExactlyOnceWith('graphql:acme.fontdue.com');
+  });
+  it('multi-tenant: 400s on a missing or invalid domain', async () => {
+    stubMultiTenant();
+    const {
+      POST
+    } = await importRevalidate();
+    for (const url of ['http://internal/api/revalidate', 'http://internal/api/revalidate?domain=not%20a%20domain']) {
+      const response = await POST(new Request(url, {
+        method: 'POST'
+      }));
+      expect(response.status).toBe(400);
+    }
+    expect(revalidateTag).not.toHaveBeenCalled();
+  });
+  it('single-tenant: purges the global graphql tag', async () => {
+    stubSingleTenant();
+    const {
+      POST
+    } = await importRevalidate();
+    const response = await POST(new Request('http://internal/api/revalidate', {
+      method: 'POST'
+    }));
+    expect(response.status).toBe(200);
+    expect(revalidateTag).toHaveBeenCalledExactlyOnceWith('graphql');
+  });
+});

package/dist/components/AddToCartBanner/index.js

@@ -1,18 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _AddToCartBannerQuery2 = _interopRequireDefault(require("../../__generated__/AddToCartBannerQuery.graphql"));
-var _AddToCartBanner_order2 = _interopRequireDefault(require("../../__generated__/AddToCartBanner_order.graphql"));
-var _AddToCartBanner_item2 = _interopRequireDefault(require("../../__generated__/AddToCartBanner_item.graphql"));
-var _react = _interopRequireWildcard(require("react"));
-var _reactRelay = require("react-relay");
-var _fastDeepEqual = _interopRequireDefault(require("fast-deep-equal"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import _AddToCartBannerQuery from "../../__generated__/AddToCartBannerQuery.graphql.js";
+import _AddToCartBanner_order from "../../__generated__/AddToCartBanner_order.graphql.js";
+import _AddToCartBanner_item from "../../__generated__/AddToCartBanner_item.graphql.js";
+import React, { useEffect, useState, useRef } from 'react';
+import { graphql, useFragment, useLazyLoadQuery } from 'react-relay';
+import equal from 'fast-deep-equal';
 const getOrderItemName = item => {
   var _item$sku;
   const product = item === null || item === void 0 ? void 0 : (_item$sku = item.sku) === null || _item$sku === void 0 ? void 0 : _item$sku.product;
@@ -30,31 +21,31 @@ const getOrderItemName = item => {
   if ('name' in product) return product.name;
   return null;
 };
-_AddToCartBanner_item2.default.hash && _AddToCartBanner_item2.default.hash !== "93905c08206c30255368dbb06f59ccec" && console.error("The definition of 'AddToCartBanner_item' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _AddToCartBanner_item2.default;
+_AddToCartBanner_item.hash && _AddToCartBanner_item.hash !== "93905c08206c30255368dbb06f59ccec" && console.error("The definition of 'AddToCartBanner_item' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _AddToCartBanner_item;
 function AddToCartBanner(_ref) {
   var _order$orderItems, _order$orderItems2;
   let {
     order: orderKey
   } = _ref;
-  const order = (0, _reactRelay.useFragment)((_AddToCartBanner_order2.default.hash && _AddToCartBanner_order2.default.hash !== "29516fe27686b4937b1856979f13d22b" && console.error("The definition of 'AddToCartBanner_order' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _AddToCartBanner_order2.default), orderKey);
-  const [active, setActive] = (0, _react.useState)(false);
-  const prevOrderItemIds = (0, _react.useRef)(order === null || order === void 0 ? void 0 : (_order$orderItems = order.orderItems) === null || _order$orderItems === void 0 ? void 0 : _order$orderItems.map(item => item.id));
-  const newOrderItemIds = (0, _react.useRef)([]);
+  const order = useFragment((_AddToCartBanner_order.hash && _AddToCartBanner_order.hash !== "29516fe27686b4937b1856979f13d22b" && console.error("The definition of 'AddToCartBanner_order' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _AddToCartBanner_order), orderKey);
+  const [active, setActive] = useState(false);
+  const prevOrderItemIds = useRef(order === null || order === void 0 ? void 0 : (_order$orderItems = order.orderItems) === null || _order$orderItems === void 0 ? void 0 : _order$orderItems.map(item => item.id));
+  const newOrderItemIds = useRef([]);
   const newOrderItems = order === null || order === void 0 ? void 0 : (_order$orderItems2 = order.orderItems) === null || _order$orderItems2 === void 0 ? void 0 : _order$orderItems2.filter(item => {
     var _newOrderItemIds$curr;
     return (_newOrderItemIds$curr = newOrderItemIds.current) === null || _newOrderItemIds$curr === void 0 ? void 0 : _newOrderItemIds$curr.includes(item.id);
   });
-  const timeoutRef = (0, _react.useRef)(undefined);
-  (0, _react.useEffect)(() => {
+  const timeoutRef = useRef(undefined);
+  useEffect(() => {
     document.body.dataset.addToCartBannerOpen = `${active}`;
   }, [active]);
-  (0, _react.useEffect)(() => {
+  useEffect(() => {
     var _order$orderItems3, _order$orderItems4, _prevOrderItemIds$cur;
     function setInactive() {
       setActive(false);
     }
     const orderItemIds = order === null || order === void 0 ? void 0 : (_order$orderItems3 = order.orderItems) === null || _order$orderItems3 === void 0 ? void 0 : _order$orderItems3.map(item => item.id);
-    if ((0, _fastDeepEqual.default)(orderItemIds, prevOrderItemIds.current)) return;
+    if (equal(orderItemIds, prevOrderItemIds.current)) return;
     if (((order === null || order === void 0 ? void 0 : (_order$orderItems4 = order.orderItems) === null || _order$orderItems4 === void 0 ? void 0 : _order$orderItems4.length) ?? 0) > (((_prevOrderItemIds$cur = prevOrderItemIds.current) === null || _prevOrderItemIds$cur === void 0 ? void 0 : _prevOrderItemIds$cur.length) ?? 0)) {
       setActive(true);
       if (timeoutRef.current) clearTimeout(timeoutRef.current);
@@ -70,7 +61,7 @@ function AddToCartBanner(_ref) {
     };
   }, [order === null || order === void 0 ? void 0 : order.orderItems]);
   const itemText = (newOrderItems === null || newOrderItems === void 0 ? void 0 : newOrderItems.length) === 1 ? getOrderItemName(newOrderItems[0]) : `${newOrderItems === null || newOrderItems === void 0 ? void 0 : newOrderItems.length} items`;
-  return /*#__PURE__*/_react.default.createElement("div", {
+  return /*#__PURE__*/React.createElement("div", {
     className: "add-to-cart-banner",
     "data-active": active
   }, "You added ", itemText, " to your cart");
@@ -78,10 +69,9 @@ function AddToCartBanner(_ref) {
 function AddToCartBannerQueryRenderer() {
   const {
     viewer
-  } = (0, _reactRelay.useLazyLoadQuery)((_AddToCartBannerQuery2.default.hash && _AddToCartBannerQuery2.default.hash !== "0ece6678652384f7938caf18b2a40be9" && console.error("The definition of 'AddToCartBannerQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _AddToCartBannerQuery2.default), {});
-  return /*#__PURE__*/_react.default.createElement(AddToCartBanner, {
+  } = useLazyLoadQuery((_AddToCartBannerQuery.hash && _AddToCartBannerQuery.hash !== "0ece6678652384f7938caf18b2a40be9" && console.error("The definition of 'AddToCartBannerQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _AddToCartBannerQuery), {});
+  return /*#__PURE__*/React.createElement(AddToCartBanner, {
     order: viewer.currentOrder
   });
 }
-var _default = AddToCartBannerQueryRenderer;
-exports.default = _default;
+export default AddToCartBannerQueryRenderer;

package/dist/components/BuyButton/index.d.ts

@@ -1,17 +1,40 @@
 import React from 'react';
-import { BuyButtonIDQuery } from '../../__generated__/BuyButtonIDQuery.graphql';
-import { BuyButtonSlugQuery } from '../../__generated__/BuyButtonSlugQuery.graphql';
-import { SerializablePreloadedQuery } from '../../relay/loadSerializableQuery';
+import { BuyButtonIDQuery } from '../../__generated__/BuyButtonIDQuery.graphql.js';
+import { BuyButtonSlugQuery } from '../../__generated__/BuyButtonSlugQuery.graphql.js';
+import { SerializablePreloadedQuery } from '../../relay/loadSerializableQuery.js';
+import { Config } from '../ConfigContext.js';
 export interface BuyButton_props {
-    collectionId?: string | null;
-    collectionSlug?: string | null;
     collectionName?: string;
     label?: string;
 }
+export type BuyButtonPreloadedQuery = SerializablePreloadedQuery<BuyButtonIDQuery> | SerializablePreloadedQuery<BuyButtonSlugQuery>;
+export type LoadBuyButtonQueryVariables = {
+    collectionId: string;
+    collectionSlug?: never;
+} | {
+    collectionId?: never;
+    collectionSlug: string;
+};
+export declare function loadBuyButtonQuery(variables: LoadBuyButtonQueryVariables): Promise<BuyButtonPreloadedQuery>;
 export declare function BuyButtonPreloadedIDQueryRenderer({ preloadedQuery, ...rest }: BuyButton_props & {
     preloadedQuery: SerializablePreloadedQuery<BuyButtonIDQuery>;
 }): React.JSX.Element;
 export declare function BuyButtonPreloadedSlugQueryRenderer({ preloadedQuery, ...rest }: BuyButton_props & {
     preloadedQuery: SerializablePreloadedQuery<BuyButtonSlugQuery>;
 }): React.JSX.Element;
-export default function BuyButton({ collectionId, collectionSlug, ...rest }: BuyButton_props): React.JSX.Element;
+export type BuyButton_unifiedProps = BuyButton_props & {
+    config?: Config;
+} & ({
+    preloadedQuery: BuyButtonPreloadedQuery;
+    collectionId?: never;
+    collectionSlug?: never;
+} | {
+    preloadedQuery?: never;
+    collectionId: string;
+    collectionSlug?: never;
+} | {
+    preloadedQuery?: never;
+    collectionId?: never;
+    collectionSlug: string;
+});
+export default function BuyButton(props: BuyButton_unifiedProps): React.JSX.Element;