fontdue-js 3.0.0-alpha13 → 3.0.0-alpha14

package/CHANGELOG.md

@@ -7,7 +7,7 @@ In alpha on the `alpha` dist-tag — install with `npm install fontdue-js@alpha`
   - `fontdue-js/preview` — `handlePreviewRequest` (a Web-standard enter/exit route handler), `readPreviewToken`, `previewAuthHeaders`, and the cookie/endpoint constants.
   - `fontdue-js/preview/server` — `runWithPreview`, which holds the preview token in `AsyncLocalStorage` for the duration of a request so every server fetch and preload forwards it automatically, and forces preview responses out of shared/CDN caches so an admin's render is never served to the public.
 
-  Next.js uses draft mode rather than ambient context, and needs no per-render setup call: mounting `<FontdueProvider>` wires every server fetch and the embedded components' server preloads to forward the token, apply the cache tags for `/api/revalidate`, and serve a live render while previewing — including embeds rendered inside a Server Component, which now preload server-side with the admin token instead of falling back to a client refetch. `configureFontduePreview()` (from `fontdue-js/next`) stays exported for when you want the resolved endpoint inside a render (e.g. a `metadataBase` fallback), but it's optional. See the README "Admin preview".
+  Next.js uses draft mode rather than ambient context, and needs no per-render setup call at all: mounting `<FontdueProvider>` wires every server fetch and the embedded components' server preloads to forward the token, apply the cache tags for `/api/revalidate`, and serve a live render while previewing — including embeds rendered inside a Server Component, which preload server-side with the admin token instead of falling back to a client refetch. See the README "Admin preview".
 - **One server fetch for every framework.** `fontdue-js/server` exports `createFontdueFetch({ url?, headers?, cacheTags? })` — a ready-made server-side GraphQL fetcher with URL resolution, error handling, `FontdueNotFoundError`, and automatic preview-token forwarding. Each input resolves per call from the explicit option, the per-render config (`runWithPreview` elsewhere, or the config the Next adapter resolves per render once `<FontdueProvider>` is mounted), then the environment, and passing `cacheTags` opts the fetch into Next's data cache + `/api/revalidate` (inert in other runtimes) — so Next and the other frameworks now share the same fetcher rather than Next hand-rolling its own. See the README "Server-side GraphQL fetches".
 - **Server-rendered embeds.** Components now render their full HTML on the server where the framework supports it (v2 hydrated some empty and fetched on the client), via the `load{Component}Query()` preload helpers.
 - **Migrating from v2 (Next.js)** is a small, mechanical upgrade — see the README "Migrating a Next.js site from v2". `useFontStyle` is renamed to `useFont` (the old name still works as an alias).

package/README.md

@@ -438,7 +438,7 @@ export default async function Page() {
 
 `createFontdueFetch()` resolves its config per fetch from Next's request context: it points your fetches at your site (`NEXT_PUBLIC_FONTDUE_URL`), applies the cache tags that tie them into `/api/revalidate`, and — when a logged-in admin is previewing — forwards the admin token and serves the render live (see [Admin preview](#admin-preview)). Resolving per fetch means soft navigations that re-render only the page segment are covered too, with nothing to repeat per entry point.
 
-Route handlers (robots/sitemap) aren't React renders, so they read the endpoint from `fontdueEndpoint()` (from `fontdue-js/next`; shape: `type FontdueEndpoint`) and pass it to `createFontdueFetch({ url, headers, cacheTags })` directly. `configureFontduePreview()` is still exported if you want the resolved endpoint inside a render (e.g. a `metadataBase` fallback), but it's optional now that mounting the provider wires the config up.
+Route handlers (robots/sitemap) run outside a React render, but the same `createFontdueFetch()` still resolves your site from `NEXT_PUBLIC_FONTDUE_URL`, so they need no extra setup. Their fetches aren't added to Next's data cache (there's no per-render config to tag them), which is what you want for robots/sitemap — they're cheap and rarely change.
 
 ## Migrating a Next.js site from v2
 

package/dist/__tests__/nextAdapter.test.js

@@ -174,11 +174,8 @@ describe('configureFontdueRender', () => {
     const {
       configureFontdueRender
     } = await importTenant();
-    const {
-      getFontdueSlotConfig
-    } = await import("../relay/serverConfig.js");
+    // Invalid domain returns null before any setFontdueServerConfig call.
     expect(configureFontdueRender('not a domain')).toBeNull();
-    expect(getFontdueSlotConfig()).toBeUndefined();
   });
   it('sets the per-render server config and returns the endpoint', async () => {
     stubMultiTenant({
@@ -202,8 +199,7 @@ describe('configureFontdueRender', () => {
         'x-forwarded-host': 'acme.fontdue.com',
         'x-fontdue-proxy-secret': 's3cret'
       },
-      cacheTags: ['graphql:acme.fontdue.com'],
-      domain: 'acme.fontdue.com'
+      cacheTags: ['graphql:acme.fontdue.com']
     });
   });
 });
@@ -283,62 +279,11 @@ describe('__prepareFontdueRender', () => {
     expect(config.cacheTags).toBeUndefined();
   });
 });
-describe('configureFontduePreview (single-tenant)', () => {
-  async function captureConfig() {
-    let captured;
-    vi.doMock('../relay/serverConfig', async importActual => ({
-      ...(await importActual()),
-      setFontdueServerConfig: c => {
-        captured = c;
-      }
-    }));
-    const {
-      configureFontduePreview
-    } = await importTenant();
-    const endpoint = await configureFontduePreview();
-    vi.doUnmock('../relay/serverConfig');
-    return {
-      captured,
-      endpoint
-    };
-  }
-  it('public render: configures the NEXT_PUBLIC_FONTDUE_URL site with cache tags', async () => {
-    var _captured$headers;
-    stubSingleTenant('https://acme.fontdue.com');
-    const {
-      captured,
-      endpoint
-    } = await captureConfig();
-    expect(endpoint.origin).toBe('https://acme.fontdue.com');
-    expect(captured.url).toBe('https://acme.fontdue.com');
-    expect(captured.cacheTags).toEqual(['graphql:acme.fontdue.com']);
-    expect((_captured$headers = captured.headers) === null || _captured$headers === void 0 ? void 0 : _captured$headers.authorization).toBeUndefined();
-  });
-  it('preview render: forwards the token and drops cache tags', async () => {
-    var _captured$headers2;
-    stubSingleTenant('https://acme.fontdue.com');
-    draft.enabled = true;
-    draft.token = 'admin-tok';
-    const {
-      captured
-    } = await captureConfig();
-    expect((_captured$headers2 = captured.headers) === null || _captured$headers2 === void 0 ? void 0 : _captured$headers2.authorization).toBe('Bearer admin-tok');
-    expect(captured.cacheTags).toBeUndefined();
-  });
-  it('throws a helpful error when NEXT_PUBLIC_FONTDUE_URL is unset', async () => {
-    stubMultiTenant();
-    const {
-      configureFontduePreview
-    } = await importTenant();
-    await expect(configureFontduePreview()).rejects.toThrow(/NEXT_PUBLIC_FONTDUE_URL/);
-  });
-});
 describe('single-tenant ambient resolver (no per-render call)', () => {
   // Importing registerSingleTenantResolver registers the resolver as a module
   // side effect — the FontdueProvider RSC entrypoint does this import, so
-  // merely mounting the provider wires it up. No
-  // configureFontduePreview()/__prepareFontdueRender() call is made in any of
-  // these tests; the config is pulled at fetch time.
+  // merely mounting the provider wires it up. No per-render setup call is made
+  // in any of these tests; the config is pulled at fetch time.
   it('public render: feeds the env URL + cache tags, no token', async () => {
     var _config$headers3;
     stubSingleTenant('https://acme.fontdue.com');
@@ -415,45 +360,6 @@ describe('single-tenant ambient resolver (no per-render call)', () => {
     expect(config === null || config === void 0 ? void 0 : (_config$headers5 = config.headers) === null || _config$headers5 === void 0 ? void 0 : _config$headers5.authorization).toBeUndefined();
   });
 });
-describe('fontdueEndpoint', () => {
-  it('multi-tenant: throws when no render config was set', async () => {
-    stubMultiTenant({
-      origin: 'http://app:4000'
-    });
-    const {
-      fontdueEndpoint
-    } = await importTenant();
-    expect(() => fontdueEndpoint()).toThrow(/__prepareFontdueRender/);
-  });
-  it('single-tenant: derives the endpoint from NEXT_PUBLIC_FONTDUE_URL', async () => {
-    stubSingleTenant('https://acme.fontdue.com');
-    const {
-      fontdueEndpoint
-    } = await importTenant();
-    expect(fontdueEndpoint()).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()),
-      getFontdueSlotConfig: () => ({
-        domain: 'acme.fontdue.com'
-      })
-    }));
-    const {
-      fontdueEndpoint
-    } = await importTenant();
-    expect(fontdueEndpoint().headers['x-forwarded-host']).toBe('acme.fontdue.com');
-    vi.doUnmock('../relay/serverConfig');
-  });
-});
 
 // withFontdue detects the route-tree shape from the working directory; give
 // it one with or without src/app/[domain].

package/dist/next/index.d.ts

@@ -1 +1 @@
-export { configureFontduePreview, fontdueEndpoint, __prepareFontdueRender, type FontdueEndpoint, } from './tenant.js';
+export { __prepareFontdueRender, type FontdueEndpoint } from './tenant.js';

package/dist/next/index.js

@@ -2,19 +2,17 @@
 // The config-time wrapper lives in 'fontdue-js/next/config' and the deploy
 // hook route handler in 'fontdue-js/next/revalidate'.
 
-// Public foundry-facing API. Single-tenant apps need no per-render setup call —
+// Single-tenant apps need NO per-render setup and nothing from this entrypoint:
 // mounting <FontdueProvider> registers the ambient resolver that configures
-// every server fetch (see ../components/FontdueProvider/index.server.tsx ->
-// registerSingleTenantResolver). configureFontduePreview() remains exported as
-// an optional explicit hook (e.g. to get the resolved endpoint in a render);
-// route handlers (sitemap, robots) read fontdueEndpoint() since they run
-// outside React.
+// every server fetch — your own (createFontdueFetch) and the embedded
+// components' preloads, including the admin preview token (see
+// ../components/FontdueProvider/index.server.tsx -> registerSingleTenantResolver).
 //
-// __prepareFontdueRender is the internal multi-tenant API used only by the
-// Fontdue-hosted next-template — not part of the foundry surface. The
-// remaining tenant/config helpers (isMultiTenant, isValidDomain,
-// endpointForDomain, fontdueServerConfig, configureFontdueRender,
-// setFontdueServerConfig/getFontdueSlotConfig) are deliberately not re-exported
-// here; the modules that need them import them directly from './tenant.js' /
-// '../relay/serverConfig.js'.
-export { configureFontduePreview, fontdueEndpoint, __prepareFontdueRender } from './tenant.js';
+// __prepareFontdueRender is the internal multi-tenant API (double-underscored)
+// used only by the Fontdue-hosted next-template — not part of the foundry
+// surface — and FontdueEndpoint is its return type. The remaining tenant/config
+// helpers (isMultiTenant, isValidDomain, endpointForDomain, fontdueServerConfig,
+// configureFontdueRender, setFontdueServerConfig) are deliberately not
+// re-exported here; the modules that need them import them directly from
+// './tenant.js' / '../relay/serverConfig.js'.
+export { __prepareFontdueRender } from './tenant.js';

package/dist/next/registerSingleTenantResolver.js

@@ -28,9 +28,8 @@ registerAmbientConfigResolver(async () => {
   } = await import('./tenant.js');
   // Multi-tenant drives config through the React.cache slot
   // (__prepareFontdueRender), which needs the per-request route param, so the
-  // resolver stays out of its way. The slot also wins the merge, so an
-  // explicit configureFontduePreview()/__prepareFontdueRender call still
-  // overrides this when present.
+  // resolver stays out of its way. The slot also wins the merge, so a
+  // multi-tenant __prepareFontdueRender call still overrides this when present.
   if (isMultiTenant || !singleTenantUrl) return undefined;
   return buildRenderConfig(new URL(singleTenantUrl).host);
 });

package/dist/next/tenant.d.ts

@@ -22,7 +22,5 @@ interface RenderProps {
     params: Promise<Record<string, string | string[] | undefined>>;
 }
 export declare function buildRenderConfig(domain: string): Promise<FontdueServerConfig>;
-export declare function configureFontduePreview(): Promise<FontdueEndpoint>;
 export declare function __prepareFontdueRender(props: RenderProps): Promise<FontdueEndpoint>;
-export declare function fontdueEndpoint(): FontdueEndpoint;
 export {};

package/dist/next/tenant.js

@@ -20,13 +20,14 @@
 //
 // The fontdue-js components embedded in pages fetch the same way: their
 // server-side preloads read the per-render config set by
-// __prepareFontdueRender (or configureFontduePreview in single-tenant apps),
-// and in the browser they fetch the relative /graphql on the page's own
-// origin — so multi-tenant mode needs no NEXT_PUBLIC_FONTDUE_URL at all.
+// __prepareFontdueRender (multi-tenant) or, in single-tenant apps, the ambient
+// resolver that <FontdueProvider> registers — no per-render setup call — and in
+// the browser they fetch the relative /graphql on the page's own origin, so
+// multi-tenant mode needs no NEXT_PUBLIC_FONTDUE_URL at all.
 
 import { notFound, unstable_rethrow } from 'next/navigation';
 import { cookies, draftMode } from 'next/headers';
-import { setFontdueServerConfig, getFontdueSlotConfig } from '../relay/serverConfig.js';
+import { setFontdueServerConfig } from '../relay/serverConfig.js';
 import { PREVIEW_TOKEN_COOKIE, previewAuthHeaders } from '../preview/index.js';
 export const isMultiTenant = process.env.FONTDUE_MULTI_TENANT === '1';
 export const singleTenantUrl = process.env.NEXT_PUBLIC_FONTDUE_URL;
@@ -90,8 +91,7 @@ export function fontdueServerConfig(domain) {
   return {
     url: origin,
     headers,
-    cacheTags: [`graphql:${domain}`],
-    domain
+    cacheTags: [`graphql:${domain}`]
   };
 }
 
@@ -134,32 +134,6 @@ async function applyRenderConfig(domain) {
   setFontdueServerConfig(await buildRenderConfig(domain));
 }
 
-// Single-tenant render setup — the one line at the top of every page, layout
-// and generateMetadata that fetches Fontdue data or renders Fontdue components:
-//
-//   await configureFontduePreview();
-//
-// It points this render's server-side fetches — your own (createFontdueFetch)
-// AND the embedded components' preloads (type testers, store, character viewer)
-// — at your Fontdue site (NEXT_PUBLIC_FONTDUE_URL), and when a logged-in admin
-// has entered preview it forwards their token and serves a live (uncached)
-// render so hidden (unpublished) fonts show up. Public renders stay cached and
-// tagged for /api/revalidate.
-//
-// Call it per entry point, not just the layout: a soft navigation re-renders
-// only the page segment with a fresh render store. Reading draft mode is
-// static-safe — it only forces dynamic rendering when an admin is actually
-// previewing, so static generation keeps working otherwise.
-//
-// Returns the endpoint, handy for e.g. a metadataBase fallback. Route handlers
-// (robots/sitemap) aren't React renders, so call fontdueEndpoint()
-// there instead.
-export async function configureFontduePreview() {
-  const domain = new URL(requireSingleTenantUrl()).host;
-  await applyRenderConfig(domain);
-  return endpointForDomain(domain);
-}
-
 // Internal multi-tenant API (double-underscored, not part of the public
 // foundry surface): the one line at the top of every page, layout and
 // generateMetadata body in the multi-tenant [domain] route tree (the
@@ -169,8 +143,9 @@ export async function configureFontduePreview() {
 //
 // Reads the request's site from the route param, 404s anything that isn't a
 // plain hostname, and configures the render (including preview) for that site.
-// Like configureFontduePreview, it runs per entry point. Route handlers are not
-// React renders — use the returned endpoint explicitly there.
+// It runs per entry point: a soft navigation re-renders only the page segment
+// with a fresh render store. Route handlers are not React renders — use the
+// returned endpoint explicitly there.
 export async function __prepareFontdueRender(props) {
   const {
     domain
@@ -217,23 +192,6 @@ async function readPreviewHeaders() {
   }
 }
 
-// Endpoint for the app's own GraphQL fetches in this render pass: whatever
-// __prepareFontdueRender configured, or — in a single-tenant app without the
-// [domain] tree, where __prepareFontdueRender is never called — the
-// NEXT_PUBLIC_FONTDUE_URL site. Throwing rather than guessing in
-// multi-tenant mode turns a forgotten __prepareFontdueRender into an
-// unmissable error instead of a silent wrong-site fetch on soft
-// navigations.
-export function fontdueEndpoint() {
-  var _getFontdueSlotConfig;
-  const domain = (_getFontdueSlotConfig = getFontdueSlotConfig()) === null || _getFontdueSlotConfig === void 0 ? void 0 : _getFontdueSlotConfig.domain;
-  if (domain) return endpointForDomain(domain);
-  if (isMultiTenant) {
-    throw new Error('fontdue-js/next: no render config set — call __prepareFontdueRender(props) at the top of every page, layout and generateMetadata that fetches.');
-  }
-  return endpointForDomain(new URL(requireSingleTenantUrl()).host);
-}
-
 // The single-tenant ambient resolver that lets a foundry skip per-render setup
 // is registered from ./registerSingleTenantResolver.ts (imported as a side
 // effect by the FontdueProvider react-server entrypoint), not here — so this

package/dist/relay/environment.js

@@ -7,7 +7,7 @@ import { PREVIEW_HEADER, hasPreviewMarkerCookie } from '../preview/constants.js'
 // (defineVersionPlugin in .babelrc.cjs) with the literal package.json#version.
 // Exported so UI (the admin toolbar) can surface it without re-reading the
 // build-time global in a 'use client' module.
-export const version = "3.0.0-alpha13";
+export const version = "3.0.0-alpha14";
 const IS_SERVER = typeof window === typeof undefined;
 
 // Read env from either process.env (Node/Next.js) or import.meta.env (Vite/Astro).

package/dist/relay/serverConfig.d.ts

@@ -5,17 +5,10 @@ export interface FontdueServerConfig {
     headers?: Record<string, string>;
     /** Extra Next.js fetch cache tags applied to every server-side GraphQL fetch. */
     cacheTags?: string[];
-    /**
-     * The site domain this render is for, when known. Set by
-     * fontdue-js/next's __prepareFontdueRender so render-scoped helpers
-     * (fontdueEndpoint) can recover it.
-     */
-    domain?: string;
 }
 type MaybePromise<T> = T | Promise<T>;
 type AmbientConfigResolver = () => MaybePromise<FontdueServerConfig | undefined>;
 export declare function setFontdueServerConfig(config: FontdueServerConfig): void;
 export declare function registerAmbientConfigResolver(resolver: AmbientConfigResolver): void;
-export declare function getFontdueSlotConfig(): FontdueServerConfig | undefined;
 export declare function resolveFontdueServerConfig(): Promise<FontdueServerConfig | undefined>;
 export {};

package/dist/relay/serverConfig.js

@@ -99,18 +99,6 @@ function mergeServerConfig(ambient, slot) {
   };
 }
 
-// Slot-only read of the render-scoped config. It deliberately does NOT run the
-// ambient resolver: the single-tenant Next resolver is async (it awaits
-// draftMode()/cookies()), so a synchronous read could never reflect it without
-// silently dropping the preview token. Anything that needs the resolved
-// url/headers — every server-side fetch — must use resolveFontdueServerConfig()
-// instead. This exists only to recover the multi-tenant `domain` the slot
-// carries (set by __prepareFontdueRender), which fontdueEndpoint() reads from a
-// synchronous path.
-export function getFontdueSlotConfig() {
-  return store().getSlot().current;
-}
-
 // Asynchronous read used by the server-side fetch paths (the Relay network
 // layer and createFontdueFetch). Awaits the ambient resolver so a resolver that
 // reads request-scoped async APIs (Next's draftMode()/cookies()) can feed

package/dist/server/index.js

@@ -15,9 +15,10 @@
 //   1. Ambient context (preferred): whatever set the per-render config.
 //      - Astro / React Router etc.: runWithPreview (fontdue-js/preview/server)
 //        rides the token through AsyncLocalStorage.
-//      - Next: configureFontduePreview / __prepareFontdueRender
-//        (fontdue-js/next) write the site URL, cache tags, and preview token
-//        into the render-scoped slot.
+//      - Next: the single-tenant ambient resolver (registered by mounting
+//        <FontdueProvider>, no per-render call) or __prepareFontdueRender
+//        (fontdue-js/next, multi-tenant) supply the site URL, cache tags, and
+//        preview token for the render.
 //      Either way:
 //
 //        const fetchGraphql = createFontdueFetch();           // once, at module scope

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fontdue-js",
-  "version": "3.0.0-alpha13",
+  "version": "3.0.0-alpha14",
   "type": "module",
   "scripts": {
     "build": "npm run relay && run-p build-js build-css build-ts",