fontdue-js 3.0.0-alpha10 → 3.0.0-alpha11

package/dist/__generated__/FontdueAdminToolbarQuery.graphql.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @generated SignedSource<<c46bd30612c05d6cd1c334c403aafb35>>
+ * @lightSyntaxTransform
+ * @nogrep
+ */
+import { ConcreteRequest } from 'relay-runtime';
+export type FontdueAdminToolbarQuery$variables = Record<PropertyKey, never>;
+export type FontdueAdminToolbarQuery$data = {
+    readonly viewer: {
+        readonly adminUser: {
+            readonly name: string | null;
+        } | null;
+    };
+};
+export type FontdueAdminToolbarQuery = {
+    response: FontdueAdminToolbarQuery$data;
+    variables: FontdueAdminToolbarQuery$variables;
+};
+declare const node: ConcreteRequest;
+export default node;

package/dist/__generated__/FontdueAdminToolbarQuery.graphql.js

@@ -0,0 +1,80 @@
+/**
+ * @generated SignedSource<<c46bd30612c05d6cd1c334c403aafb35>>
+ * @lightSyntaxTransform
+ * @nogrep
+ */
+
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+
+const node = function () {
+  var v0 = {
+    "alias": null,
+    "args": null,
+    "concreteType": "User",
+    "kind": "LinkedField",
+    "name": "adminUser",
+    "plural": false,
+    "selections": [{
+      "alias": null,
+      "args": null,
+      "kind": "ScalarField",
+      "name": "name",
+      "storageKey": null
+    }],
+    "storageKey": null
+  };
+  return {
+    "fragment": {
+      "argumentDefinitions": [],
+      "kind": "Fragment",
+      "metadata": null,
+      "name": "FontdueAdminToolbarQuery",
+      "selections": [{
+        "alias": null,
+        "args": null,
+        "concreteType": "Viewer",
+        "kind": "LinkedField",
+        "name": "viewer",
+        "plural": false,
+        "selections": [v0 /*: any*/],
+        "storageKey": null
+      }],
+      "type": "RootQueryType",
+      "abstractKey": null
+    },
+    "kind": "Request",
+    "operation": {
+      "argumentDefinitions": [],
+      "kind": "Operation",
+      "name": "FontdueAdminToolbarQuery",
+      "selections": [{
+        "alias": null,
+        "args": null,
+        "concreteType": "Viewer",
+        "kind": "LinkedField",
+        "name": "viewer",
+        "plural": false,
+        "selections": [v0 /*: any*/, {
+          "alias": null,
+          "args": null,
+          "kind": "ScalarField",
+          "name": "id",
+          "storageKey": null
+        }],
+        "storageKey": null
+      }]
+    },
+    "params": {
+      "cacheID": "a48946b192fea90930ffac67eff7b1b5",
+      "id": null,
+      "metadata": {},
+      "name": "FontdueAdminToolbarQuery",
+      "operationKind": "query",
+      "text": "query FontdueAdminToolbarQuery {\n  viewer {\n    adminUser {\n      name\n    }\n    id\n  }\n}\n"
+    }
+  };
+}();
+node.hash = "8660b45f086137d249eee82459ad648d";
+export default node;

package/dist/__tests__/createFontdueFetch.test.js

@@ -0,0 +1,104 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createFontdueFetch, FontdueNotFoundError } from '../server/index.js';
+beforeEach(() => {
+  vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
+});
+function mockFetch(impl) {
+  const fetchMock = vi.fn(async (url, init) => impl(url, init));
+  vi.stubGlobal('fetch', fetchMock);
+  return fetchMock;
+}
+describe('createFontdueFetch', () => {
+  it('posts the query to the configured URL and unwraps data', async () => {
+    const fetchMock = mockFetch(() => ({
+      status: 200,
+      json: async () => ({
+        data: {
+          viewer: {
+            id: '1'
+          }
+        }
+      })
+    }));
+    const fetchGraphql = createFontdueFetch({
+      url: 'https://acme.fontdue.com'
+    });
+    const data = await fetchGraphql('Index', 'query Index { viewer { id } }', {
+      a: 1
+    });
+    expect(data).toEqual({
+      viewer: {
+        id: '1'
+      }
+    });
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe('https://acme.fontdue.com/graphql?query=Index');
+    expect(init.method).toBe('POST');
+    expect(JSON.parse(init.body)).toEqual({
+      query: 'query Index { viewer { id } }',
+      variables: {
+        a: 1
+      }
+    });
+  });
+  it('forwards bound headers (the preview Bearer token) on every call', async () => {
+    const fetchMock = mockFetch(() => ({
+      status: 200,
+      json: async () => ({
+        data: {}
+      })
+    }));
+    const fetchGraphql = createFontdueFetch({
+      url: 'https://acme.fontdue.com',
+      headers: {
+        authorization: 'Bearer admin-tok'
+      }
+    });
+    await fetchGraphql('A', 'query A { __typename }');
+    await fetchGraphql('B', 'query B { __typename }');
+    for (const call of fetchMock.mock.calls) {
+      const init = call[1];
+      expect(init.headers.authorization).toBe('Bearer admin-tok');
+    }
+  });
+  it('throws FontdueNotFoundError on a 404 (host did not resolve)', async () => {
+    mockFetch(() => ({
+      status: 404,
+      json: async () => ({})
+    }));
+    const fetchGraphql = createFontdueFetch({
+      url: 'https://acme.fontdue.com'
+    });
+    await expect(fetchGraphql('X', 'query X { __typename }')).rejects.toBeInstanceOf(FontdueNotFoundError);
+  });
+  it('throws on GraphQL errors in a 200 response', async () => {
+    mockFetch(() => ({
+      status: 200,
+      json: async () => ({
+        errors: [{
+          message: 'boom'
+        }]
+      })
+    }));
+    const fetchGraphql = createFontdueFetch({
+      url: 'https://acme.fontdue.com'
+    });
+    await expect(fetchGraphql('X', 'query X { __typename }')).rejects.toThrow('boom');
+  });
+  it('resolves the URL from the environment when none is passed', async () => {
+    vi.stubEnv('FONTDUE_URL', 'https://env.fontdue.com');
+    const fetchMock = mockFetch(() => ({
+      status: 200,
+      json: async () => ({
+        data: {}
+      })
+    }));
+    const fetchGraphql = createFontdueFetch();
+    await fetchGraphql('Q', 'query Q { __typename }');
+    expect(fetchMock.mock.calls[0][0]).toBe('https://env.fontdue.com/graphql?query=Q');
+  });
+  it('throws a helpful error when no URL is configured', () => {
+    expect(() => createFontdueFetch()).toThrow(/no Fontdue URL configured/);
+  });
+});

package/dist/__tests__/imageLoader.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import fontdueImageLoader from '../next/image-loader.js';
+
+// The loader reads NEXT_PUBLIC_FONTDUE_IMAGE_HOST / _ORIGINS at call time, so
+// each test stubs them and we clear stubs afterwards.
+afterEach(() => {
+  vi.unstubAllEnvs();
+});
+function load(src) {
+  let origins = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let host = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'img.fontdue.xyz';
+  vi.stubEnv('NEXT_PUBLIC_FONTDUE_IMAGE_HOST', host);
+  vi.stubEnv('NEXT_PUBLIC_FONTDUE_IMAGE_ORIGINS', origins);
+  return fontdueImageLoader({
+    src,
+    width: 800,
+    quality: 75
+  });
+}
+const transformed = src => `https://img.fontdue.xyz/cdn-cgi/image/width=800,quality=75,format=auto/${src}`;
+describe('fontdueImageLoader', () => {
+  it('transforms any absolute src when no allowlist is set', () => {
+    const src = 'https://anywhere.example/a.jpg';
+    expect(load(src)).toBe(transformed(src));
+  });
+  it('serves relative srcs as-is', () => {
+    expect(load('/logo.svg', 'cdn.fontdue.xyz')).toBe('/logo.svg');
+  });
+  it('serves srcs as-is when no transform host is configured', () => {
+    const src = 'https://cdn.fontdue.xyz/a.jpg';
+    expect(load(src, 'cdn.fontdue.xyz', '')).toBe(src);
+  });
+  describe('origins allowlist', () => {
+    it('transforms an exact hostname match and skips a non-match', () => {
+      const ok = 'https://cdn.fontdue.xyz/a.jpg';
+      const no = 'https://other.example/a.jpg';
+      expect(load(ok, 'cdn.fontdue.xyz')).toBe(transformed(ok));
+      expect(load(no, 'cdn.fontdue.xyz')).toBe(no);
+    });
+    it('matches a "*." wildcard against any subdomain', () => {
+      const cdn = 'https://cdn.fontdue.xyz/a.jpg';
+      const assets = 'https://assets.fontdue.xyz/a.jpg';
+      expect(load(cdn, '*.fontdue.xyz')).toBe(transformed(cdn));
+      expect(load(assets, '*.fontdue.xyz')).toBe(transformed(assets));
+    });
+    it('does not let a wildcard match the apex or a lookalike domain', () => {
+      const apex = 'https://fontdue.xyz/a.jpg';
+      const lookalike = 'https://evilfontdue.xyz/a.jpg';
+      expect(load(apex, '*.fontdue.xyz')).toBe(apex);
+      expect(load(lookalike, '*.fontdue.xyz')).toBe(lookalike);
+    });
+    it('ignores an optional scheme on allowlist entries', () => {
+      const src = 'https://cdn.fontdue.xyz/a.jpg';
+      expect(load(src, 'https://cdn.fontdue.xyz')).toBe(transformed(src));
+      expect(load(src, 'https://*.fontdue.xyz')).toBe(transformed(src));
+    });
+    it('supports a comma-separated list', () => {
+      const src = 'https://assets.fontdue.xyz/a.jpg';
+      expect(load(src, 'cdn.fontdue.xyz, assets.fontdue.xyz')).toBe(transformed(src));
+    });
+  });
+});

package/dist/__tests__/networkFetch.test.js

@@ -63,4 +63,26 @@ describe('createNetworkFetch (server)', () => {
     expect(options.headers['x-forwarded-host']).toBe('acme.fontdue.com');
     expect(options.next.tags).toContain('graphql:acme.fontdue.com');
   });
+  it('forwards per-call options.headers (e.g. a preview Bearer token)', async () => {
+    vi.stubEnv('FONTDUE_URL', 'https://acme.fontdue.com');
+    const fetchMock = vi.fn(async () => ({
+      json: async () => ({
+        data: {}
+      })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    // This is the non-RSC path: the render-scoped serverConfig store is a
+    // no-op outside an RSC render, so apps forward the token per call instead.
+    const {
+      createNetworkFetch
+    } = await import("../relay/environment.js");
+    await createNetworkFetch({
+      headers: {
+        authorization: 'Bearer preview-tok'
+      }
+    })(request, {});
+    const [, options] = fetchMock.mock.calls[0];
+    expect(options.headers.authorization).toBe('Bearer preview-tok');
+  });
 });

package/dist/__tests__/preview.test.js

@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'vitest';
+import { handlePreviewRequest, readPreviewToken, previewAuthHeaders, PREVIEW_TOKEN_COOKIE, PREVIEW_MARKER_COOKIE } from '../preview/index.js';
+function postPreview(token) {
+  let url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'https://site.test/api/preview';
+  return handlePreviewRequest(new Request(url, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({
+      token
+    })
+  }));
+}
+describe('handlePreviewRequest', () => {
+  it('enters preview: sets an httpOnly token cookie + a readable marker', async () => {
+    const res = await postPreview('admin.tok.123');
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({
+      ok: true,
+      preview: true
+    });
+    const cookies = res.headers.getSetCookie();
+    const tokenCookie = cookies.find(c => c.startsWith(`${PREVIEW_TOKEN_COOKIE}=`));
+    const markerCookie = cookies.find(c => c.startsWith(`${PREVIEW_MARKER_COOKIE}=`));
+    expect(tokenCookie).toContain(`${PREVIEW_TOKEN_COOKIE}=admin.tok.123`);
+    expect(tokenCookie).toContain('HttpOnly');
+    expect(tokenCookie).toContain('SameSite=Lax');
+    expect(tokenCookie).toContain('Path=/');
+    expect(markerCookie).toContain(`${PREVIEW_MARKER_COOKIE}=1`);
+    // The marker must be readable by the client toolbar.
+    expect(markerCookie).not.toContain('HttpOnly');
+  });
+  it('marks cookies Secure on https and not on http (local dev)', async () => {
+    const httpsCookies = (await postPreview('t')).headers.getSetCookie();
+    expect(httpsCookies.every(c => c.includes('Secure'))).toBe(true);
+    const httpCookies = (await postPreview('t', 'http://localhost:4321/api/preview')).headers.getSetCookie();
+    expect(httpCookies.some(c => c.includes('Secure'))).toBe(false);
+  });
+  it('rejects a POST with no token', async () => {
+    const res = await postPreview('');
+    expect(res.status).toBe(400);
+    expect(res.headers.getSetCookie()).toHaveLength(0);
+  });
+  it('exits preview: clears both cookies', async () => {
+    const res = await handlePreviewRequest(new Request('https://site.test/api/preview', {
+      method: 'DELETE'
+    }));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({
+      ok: true,
+      preview: false
+    });
+    const cookies = res.headers.getSetCookie();
+    expect(cookies).toHaveLength(2);
+    // Expiry via Max-Age=0 clears the cookie.
+    expect(cookies.every(c => c.includes('Max-Age=0'))).toBe(true);
+  });
+  it('rejects unsupported methods', async () => {
+    const res = await handlePreviewRequest(new Request('https://site.test/api/preview', {
+      method: 'GET'
+    }));
+    expect(res.status).toBe(405);
+  });
+  it('round-trips a token with cookie-unsafe characters', async () => {
+    const token = 'tok+en/with=specials';
+    const res = await postPreview(token);
+    const setCookie = res.headers.getSetCookie().find(c => c.startsWith(`${PREVIEW_TOKEN_COOKIE}=`));
+    // Reconstruct the Cookie header the browser would send back (name=value).
+    const cookieHeader = setCookie.split(';')[0];
+    expect(readPreviewToken(cookieHeader)).toBe(token);
+  });
+});
+describe('readPreviewToken', () => {
+  it('extracts the token from a multi-cookie header', () => {
+    expect(readPreviewToken(`a=1; ${PREVIEW_TOKEN_COOKIE}=abc; ${PREVIEW_MARKER_COOKIE}=1`)).toBe('abc');
+  });
+  it('returns undefined when there is no token cookie', () => {
+    expect(readPreviewToken('a=1; b=2')).toBeUndefined();
+    expect(readPreviewToken('')).toBeUndefined();
+    expect(readPreviewToken(null)).toBeUndefined();
+    expect(readPreviewToken(undefined)).toBeUndefined();
+  });
+});
+describe('previewAuthHeaders', () => {
+  it('builds a Bearer header when a token is present', () => {
+    expect(previewAuthHeaders('abc')).toEqual({
+      authorization: 'Bearer abc'
+    });
+  });
+  it('returns an empty object when there is no token (safe to spread)', () => {
+    expect(previewAuthHeaders(undefined)).toEqual({});
+    expect(previewAuthHeaders(null)).toEqual({});
+    expect(previewAuthHeaders('')).toEqual({});
+  });
+});

package/dist/__tests__/previewServer.test.js

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { runWithPreview, isPreviewing, ambientPreviewHeaders } from '../preview/server.js';
+import { createFontdueFetch } from '../server/index.js';
+import { PREVIEW_TOKEN_COOKIE } from '../preview/constants.js';
+beforeEach(() => {
+  vi.unstubAllGlobals();
+});
+function req(token) {
+  return new Request('https://store.test/', {
+    headers: token ? {
+      cookie: `${PREVIEW_TOKEN_COOKIE}=${token}`
+    } : {}
+  });
+}
+describe('runWithPreview', () => {
+  it('passes public (no-token) requests through untouched and cacheable', async () => {
+    const response = await runWithPreview(req(), async () => {
+      expect(isPreviewing()).toBe(false);
+      return new Response('ok', {
+        headers: {
+          'Netlify-CDN-Cache-Control': 'public, durable, s-maxage=300'
+        }
+      });
+    });
+    expect(response.headers.get('Cache-Control')).toBeNull();
+    expect(response.headers.get('Netlify-CDN-Cache-Control')).toBe('public, durable, s-maxage=300');
+  });
+  it('exposes the token in ambient context while previewing', async () => {
+    await runWithPreview(req('tok123'), async () => {
+      expect(isPreviewing()).toBe(true);
+      expect(ambientPreviewHeaders()).toEqual({
+        authorization: 'Bearer tok123'
+      });
+      return new Response('ok');
+    });
+
+    // Context unwinds after the request.
+    expect(isPreviewing()).toBe(false);
+    expect(ambientPreviewHeaders()).toEqual({});
+  });
+  it('forces preview responses out of any shared/CDN cache', async () => {
+    const response = await runWithPreview(req('tok123'), async () => new Response('secret', {
+      headers: {
+        'Netlify-CDN-Cache-Control': 'public, durable, s-maxage=31536000',
+        'CDN-Cache-Control': 'public, s-maxage=300',
+        'Cache-Control': 'public, max-age=0, must-revalidate'
+      }
+    }));
+    expect(response.headers.get('Cache-Control')).toBe('private, no-store');
+    expect(response.headers.get('Netlify-CDN-Cache-Control')).toBeNull();
+    expect(response.headers.get('CDN-Cache-Control')).toBeNull();
+  });
+  it('isolates concurrent preview contexts (no cross-request leak)', async () => {
+    const seen = {};
+    await Promise.all([runWithPreview(req('tokA'), async () => {
+      await new Promise(r => setTimeout(r, 15));
+      seen.a = ambientPreviewHeaders().authorization;
+      return new Response('a');
+    }), runWithPreview(req('tokB'), async () => {
+      seen.b = ambientPreviewHeaders().authorization;
+      return new Response('b');
+    }), runWithPreview(req(), async () => {
+      seen.public = ambientPreviewHeaders().authorization;
+      return new Response('public');
+    })]);
+    expect(seen.a).toBe('Bearer tokA');
+    expect(seen.b).toBe('Bearer tokB');
+    expect(seen.public).toBeUndefined();
+  });
+});
+describe('createFontdueFetch + ambient preview', () => {
+  function mockFetch() {
+    const fetchMock = vi.fn(async () => ({
+      status: 200,
+      json: async () => ({
+        data: {}
+      })
+    }));
+    vi.stubGlobal('fetch', fetchMock);
+    return fetchMock;
+  }
+  it('a module-level fetcher forwards the ambient token, no per-call plumbing', async () => {
+    const fetchMock = mockFetch();
+    const fetchGraphql = createFontdueFetch({
+      url: 'https://acme.fontdue.com'
+    });
+    await runWithPreview(req('admin-tok'), async () => {
+      await fetchGraphql('Q', 'query Q { __typename }');
+      return new Response('ok');
+    });
+    const init = fetchMock.mock.calls[0][1];
+    expect(init.headers.authorization).toBe('Bearer admin-tok');
+  });
+  it('does not forward a token for public requests', async () => {
+    const fetchMock = mockFetch();
+    const fetchGraphql = createFontdueFetch({
+      url: 'https://acme.fontdue.com'
+    });
+    await fetchGraphql('Q', 'query Q { __typename }');
+    const init = fetchMock.mock.calls[0][1];
+    expect(init.headers.authorization).toBeUndefined();
+  });
+  it('explicit per-fetcher headers override the ambient context', async () => {
+    const fetchMock = mockFetch();
+    const fetchGraphql = createFontdueFetch({
+      url: 'https://acme.fontdue.com',
+      headers: {
+        authorization: 'Bearer explicit'
+      }
+    });
+    await runWithPreview(req('ambient-tok'), async () => {
+      await fetchGraphql('Q', 'query Q { __typename }');
+      return new Response('ok');
+    });
+    const init = fetchMock.mock.calls[0][1];
+    expect(init.headers.authorization).toBe('Bearer explicit');
+  });
+});

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

@@ -1,7 +1,7 @@
 import React from 'react';
 import { BuyButtonIDQuery } from '../../__generated__/BuyButtonIDQuery.graphql.js';
 import { BuyButtonSlugQuery } from '../../__generated__/BuyButtonSlugQuery.graphql.js';
-import { SerializablePreloadedQuery } from '../../relay/loadSerializableQuery.js';
+import { SerializablePreloadedQuery, type LoadQueryOptions } from '../../relay/loadSerializableQuery.js';
 import { Config } from '../ConfigContext.js';
 export interface BuyButton_props {
     collectionName?: string;
@@ -15,7 +15,7 @@ export type LoadBuyButtonQueryVariables = {
     collectionId?: never;
     collectionSlug: string;
 };
-export declare function loadBuyButtonQuery(variables: LoadBuyButtonQueryVariables): Promise<BuyButtonPreloadedQuery>;
+export declare function loadBuyButtonQuery(variables: LoadBuyButtonQueryVariables, options?: LoadQueryOptions): Promise<BuyButtonPreloadedQuery>;
 export declare function BuyButtonPreloadedIDQueryRenderer({ preloadedQuery, ...rest }: BuyButton_props & {
     preloadedQuery: SerializablePreloadedQuery<BuyButtonIDQuery>;
 }): React.JSX.Element;

package/dist/components/BuyButton/index.js

@@ -57,16 +57,16 @@ function BuyButtonComponent(_ref) {
 }
 const idQuery = (_BuyButtonIDQuery.hash && _BuyButtonIDQuery.hash !== "4fbf1dbf9e6c530a5d38c697b174d8b0" && console.error("The definition of 'BuyButtonIDQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _BuyButtonIDQuery);
 const slugQuery = (_BuyButtonSlugQuery.hash && _BuyButtonSlugQuery.hash !== "6e750adea09698f7cb61f435cd88fd26" && console.error("The definition of 'BuyButtonSlugQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _BuyButtonSlugQuery);
-export async function loadBuyButtonQuery(variables) {
+export async function loadBuyButtonQuery(variables, options) {
   if (variables.collectionId) {
     return loadSerializableQuery(BuyButtonIDQueryNode, {
       collectionId: variables.collectionId
-    });
+    }, options);
   }
   if (variables.collectionSlug) {
     return loadSerializableQuery(BuyButtonSlugQueryNode, {
       collectionSlug: variables.collectionSlug
-    });
+    }, options);
   }
   throw new Error('loadBuyButtonQuery expected either a collectionId or collectionSlug');
 }

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { SerializablePreloadedQuery } from '../../relay/loadSerializableQuery.js';
+import { SerializablePreloadedQuery, type LoadQueryOptions } from '../../relay/loadSerializableQuery.js';
 import { CharacterViewerIDQuery } from '../../__generated__/CharacterViewerIDQuery.graphql.js';
 import { CharacterViewerSlugQuery } from '../../__generated__/CharacterViewerSlugQuery.graphql.js';
 import { Config } from '../ConfigContext.js';
@@ -13,7 +13,7 @@ export type LoadCharacterViewerQueryVariables = {
     collectionId?: never;
     collectionSlug: string;
 };
-export declare function loadCharacterViewerQuery(variables: LoadCharacterViewerQueryVariables): Promise<CharacterViewerPreloadedQuery>;
+export declare function loadCharacterViewerQuery(variables: LoadCharacterViewerQueryVariables, options?: LoadQueryOptions): Promise<CharacterViewerPreloadedQuery>;
 export declare function CharacterViewerPreloadedIDQueryRenderer({ preloadedQuery, ...rest }: CharacterViewer_props & {
     preloadedQuery: SerializablePreloadedQuery<CharacterViewerIDQuery>;
 }): React.JSX.Element | null;

package/dist/components/CharacterViewer/index.js

@@ -416,16 +416,16 @@ function CharacterViewerComponent(_ref3) {
 }
 const idQuery = (_CharacterViewerIDQuery.hash && _CharacterViewerIDQuery.hash !== "f90b09a4df6d95307b0a5d5fda487cdc" && console.error("The definition of 'CharacterViewerIDQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _CharacterViewerIDQuery);
 const slugQuery = (_CharacterViewerSlugQuery.hash && _CharacterViewerSlugQuery.hash !== "afa08a8f050e0434308892fea6e3c267" && console.error("The definition of 'CharacterViewerSlugQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _CharacterViewerSlugQuery);
-export async function loadCharacterViewerQuery(variables) {
+export async function loadCharacterViewerQuery(variables, options) {
   if (variables.collectionId) {
     return loadSerializableQuery(CharacterViewerIDQueryNode, {
       collectionId: variables.collectionId
-    });
+    }, options);
   }
   if (variables.collectionSlug) {
     return loadSerializableQuery(CharacterViewerSlugQueryNode, {
       collectionSlug: variables.collectionSlug
-    });
+    }, options);
   }
   throw new Error('loadCharacterViewerQuery expected either collectionId or collectionSlug');
 }

package/dist/components/ConfigContext.d.ts

@@ -23,12 +23,16 @@ interface TrackingConfig {
     consentMessage?: string;
     segment?: SegmentConfig;
 }
+interface PreviewConfig {
+    endpoint?: string;
+}
 export interface Config {
     form?: FormConfig;
     storeModal?: StoreModalConfig;
     typeTester?: TypeTesterConfig;
     stripe?: StripeConfig;
     tracking?: TrackingConfig;
+    preview?: PreviewConfig;
     corsErrorModal?: boolean;
 }
 export declare const mergeConfig: (base?: Config, override?: Config) => Config;
@@ -102,6 +106,9 @@ export declare const makeConfig: (config?: Config) => {
         consentMessage: string | undefined;
         segment: SegmentConfig | undefined;
     };
+    preview: {
+        endpoint: string;
+    };
     corsErrorModal: boolean;
 };
 declare const _default: React.Context<{
@@ -174,6 +181,9 @@ declare const _default: React.Context<{
         consentMessage: string | undefined;
         segment: SegmentConfig | undefined;
     };
+    preview: {
+        endpoint: string;
+    };
     corsErrorModal: boolean;
 }>;
 export default _default;

package/dist/components/ConfigContext.js

@@ -1,6 +1,7 @@
 'use client';
 
 import React from 'react';
+import { PREVIEW_ENDPOINT } from '../preview/constants.js';
 const makeTypeTesterConfig = config => {
   var _config$openTypeFeatu, _config$openTypeFeatu2, _config$openTypeFeatu3, _config$openTypeFeatu4, _config$size, _config$size2, _config$size3, _config$lineHeight, _config$lineHeight2, _config$lineHeight3, _config$letterSpacing, _config$letterSpacing2, _config$letterSpacing3, _config$columns, _config$columns2, _config$columns3;
   let shy = (config === null || config === void 0 ? void 0 : config.shy) ?? false;
@@ -79,7 +80,7 @@ export const mergeConfig = (base, override) => {
   return deepMerge(base, override);
 };
 export const makeConfig = config => {
-  var _config$form, _config$storeModal, _config$storeModal2, _config$storeModal3, _config$storeModal4, _config$stripe, _config$tracking, _config$tracking2, _config$tracking3, _config$tracking4;
+  var _config$form, _config$storeModal, _config$storeModal2, _config$storeModal3, _config$storeModal4, _config$stripe, _config$tracking, _config$tracking2, _config$tracking3, _config$tracking4, _config$preview;
   return {
     typeTester: makeTypeTesterConfig(config === null || config === void 0 ? void 0 : config.typeTester),
     form: {
@@ -101,6 +102,9 @@ export const makeConfig = config => {
       consentMessage: config === null || config === void 0 ? void 0 : (_config$tracking3 = config.tracking) === null || _config$tracking3 === void 0 ? void 0 : _config$tracking3.consentMessage,
       segment: config === null || config === void 0 ? void 0 : (_config$tracking4 = config.tracking) === null || _config$tracking4 === void 0 ? void 0 : _config$tracking4.segment
     },
+    preview: {
+      endpoint: (config === null || config === void 0 ? void 0 : (_config$preview = config.preview) === null || _config$preview === void 0 ? void 0 : _config$preview.endpoint) ?? PREVIEW_ENDPOINT
+    },
     corsErrorModal: (config === null || config === void 0 ? void 0 : config.corsErrorModal) ?? true
   };
 };