fontdue-js 3.0.0-alpha7 → 3.0.0-alpha9

package/dist/components/Cart/orderTracking.js

@@ -1,13 +1,6 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sendOrderTracking = sendOrderTracking;
-var _orderTrackingUpdateOrderTrackingMutation2 = _interopRequireDefault(require("../../__generated__/orderTrackingUpdateOrderTrackingMutation.graphql"));
-var _reactRelay = require("react-relay");
-var _consent = require("../ConsentBanner/consent");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import _orderTrackingUpdateOrderTrackingMutation from "../../__generated__/orderTrackingUpdateOrderTrackingMutation.graphql.js";
+import { commitMutation, graphql } from 'react-relay';
+import { hasConsent, getClientAnonymousId } from '../ConsentBanner/consent.js';
 function readCookie(name) {
   const match = document.cookie.match(new RegExp('(?:^|;\\s*)' + name + '=([^;]*)'));
   return match ? decodeURIComponent(match[1]) : undefined;
@@ -21,14 +14,14 @@ function readCookie(name) {
  *
  * Fire-and-forget: tracking must never break checkout.
  */
-function sendOrderTracking(environment) {
+export function sendOrderTracking(environment) {
   try {
-    (0, _reactRelay.commitMutation)(environment, {
-      mutation: (_orderTrackingUpdateOrderTrackingMutation2.default.hash && _orderTrackingUpdateOrderTrackingMutation2.default.hash !== "d59a127a7f140424f507ae549731bac7" && console.error("The definition of 'orderTrackingUpdateOrderTrackingMutation' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _orderTrackingUpdateOrderTrackingMutation2.default),
+    commitMutation(environment, {
+      mutation: (_orderTrackingUpdateOrderTrackingMutation.hash && _orderTrackingUpdateOrderTrackingMutation.hash !== "d59a127a7f140424f507ae549731bac7" && console.error("The definition of 'orderTrackingUpdateOrderTrackingMutation' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _orderTrackingUpdateOrderTrackingMutation),
       variables: {
         input: {
-          analyticsConsent: (0, _consent.hasConsent)('analytics'),
-          anonymousId: (0, _consent.getClientAnonymousId)(),
+          analyticsConsent: hasConsent('analytics'),
+          anonymousId: getClientAnonymousId(),
           fbp: readCookie('_fbp'),
           fbc: readCookie('_fbc'),
           url: window.location.href

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

@@ -1,4 +1,5 @@
 import React, { type JSX } from 'react';
+import { VerticalMetrics } from '../useFontStyle.js';
 import { FontStyle_fontStyle$key } from '../../__generated__/FontStyle_fontStyle.graphql.js';
 interface FontStyleProps {
     fontStyle: FontStyle_fontStyle$key;
@@ -7,6 +8,7 @@ interface FontStyleProps {
     children: ((props: {
         loaded: boolean;
         style: React.CSSProperties;
+        verticalMetrics: VerticalMetrics | null;
     }) => React.ReactNode) | React.ReactNode;
 }
 export default function FontStyle({ Component, fontStyle: fontStyleKey, style, children, ...rest }: Omit<React.HTMLAttributes<HTMLDivElement | HTMLSpanElement>, 'children'> & FontStyleProps): JSX.Element;

package/dist/components/FontStyle/index.js

@@ -13,7 +13,8 @@ export default function FontStyle(_ref) {
   const fontStyle = useFragment((_FontStyle_fontStyle.hash && _FontStyle_fontStyle.hash !== "7891603bea1a3e40f40297bf1697eb3c" && console.error("The definition of 'FontStyle_fontStyle' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _FontStyle_fontStyle), fontStyleKey);
   const {
     style: fontStyleStyle,
-    loaded
+    loaded,
+    verticalMetrics
   } = useFontStyle({
     fontStyle
   });
@@ -26,6 +27,7 @@ export default function FontStyle(_ref) {
   };
   return /*#__PURE__*/React.createElement(Component, renderProps, typeof children === 'function' ? children({
     loaded,
-    style: fontStyleStyle
+    style: fontStyleStyle,
+    verticalMetrics
   }) : children);
 }

package/dist/components/TypeTester/index.js

@@ -142,12 +142,14 @@ const TypeTester = _ref => {
   }, _ref3 => {
     let {
       loaded,
-      style
+      style,
+      verticalMetrics
     } = _ref3;
     if (loaded) {
       return /*#__PURE__*/React.createElement(TypeTesterContent, _extends({}, props, {
         ref: contentRef,
         fontStyles: style,
+        verticalMetrics: verticalMetrics,
         truncate: config.truncate,
         direction: props.direction,
         min: config.size.min,

package/dist/components/TypeTester/useTypeTesterStyler.d.ts

@@ -1,6 +1,7 @@
 import { EditorState } from 'draft-js';
 import { Alignment } from './types.js';
 import { VariableSettings } from '../../utils.js';
+import { VerticalMetrics } from '../useFontStyle.js';
 export type ColumnsConfig = false | {
     count: 'auto' | number;
     width: string;
@@ -21,13 +22,14 @@ export interface UseTypeTesterStylerProps {
     focused: boolean;
     truncate: boolean | number;
     fontStyles: React.CSSProperties;
+    verticalMetrics?: VerticalMetrics | null;
     content: EditorState;
     contentEdited: boolean;
     alignment: Alignment;
     variableSettings: VariableSettings | null;
     columns: ColumnsConfig;
 }
-declare const useTypeTesterStyler: ({ size, autofit, autofitOnChange, features, setSize, min, max, truncate, focused, lineHeight, letterSpacing, fontStyles, content, contentEdited, alignment, variableSettings, columns, }: UseTypeTesterStylerProps) => {
+declare const useTypeTesterStyler: ({ size, autofit, autofitOnChange, features, setSize, min, max, truncate, focused, lineHeight, letterSpacing, fontStyles, verticalMetrics, content, contentEdited, alignment, variableSettings, columns, }: UseTypeTesterStylerProps) => {
     ref: import("react").RefObject<HTMLDivElement | null>;
     style: import("react").CSSProperties;
 };

package/dist/components/TypeTester/useTypeTesterStyler.js

@@ -15,6 +15,7 @@ const useTypeTesterStyler = _ref => {
     lineHeight,
     letterSpacing,
     fontStyles,
+    verticalMetrics,
     content,
     contentEdited,
     alignment,
@@ -58,33 +59,82 @@ const useTypeTesterStyler = _ref => {
   const truncateLines = truncate === true ? 1 : typeof truncate === 'number' ? Math.max(0, Math.floor(truncate)) : 0;
   const shouldTruncate = truncateLines > 0 && !focused;
 
-  // The trailing ellipsis needs `-webkit-line-clamp`, which can't coexist with
-  // CSS multi-column. `columns` is set by default, so the ellipsis is only
-  // available in single-column mode; otherwise the text is hard-clipped.
-  const ellipsis = shouldTruncate && !columns;
+  // How far a line's ink spills past its line-box, top and bottom, as a fraction
+  // of the font-size (em). `fontLoader` feeds these exact metrics into the
+  // @font-face as ascent/descent-override, so this matches the browser's line
+  // geometry precisely. It is 0 once the line-height is at least the font's
+  // natural content height ((ascender − descender) / unitsPerEm) — i.e. for any
+  // normal reading line-height — and only grows for tight, overlapping setting.
+  // Kept in em (not px) so it scales with the *rendered* size, including the
+  // `--type-tester--adjustment` that shrinks the preview on mobile.
+  const lineOverflowEm = shouldTruncate && verticalMetrics && verticalMetrics.unitsPerEm > 0 ? Math.max(0, ((verticalMetrics.ascender - verticalMetrics.descender) / verticalMetrics.unitsPerEm - lineHeight) / 2) : 0;
+
+  // Columns are what make truncation overflow flow sideways — into clipped,
+  // off-screen columns — instead of stacking below the last visible line. That
+  // is what lets the metric padding reveal descenders/ascenders cleanly, and it
+  // means a multi-column tester (e.g. a 3-column specimen) truncates to
+  // `truncateLines` lines *per column*. When truncating with columns disabled we
+  // still establish a single column so the clipped overflow behaves the same way.
+  const columnStyle = columns ? {
+    columnCount: columns.count,
+    columnWidth: columns.width,
+    columnGap: columns.gap
+  } : undefined;
+
+  // A glyph's side bearings — ink that sits outside its advance width, like a
+  // leading lowercase 'j' or an italic overhang — would be shorn by the inline
+  // clip. Per-glyph bearings aren't in the font metrics, so reserve a flat 0.1em
+  // on each inline edge and cancel it with a negative margin so
+  // wrapping and text position stay put.
+  const sideBearing = shouldTruncate ? '0.1em' : '0px';
   const style = {
     fontSize: autofit ? `${size}px` : `calc(var(--type-tester--adjustment, 1) * ${size}px)`,
     lineHeight: `${lineHeight}`,
-    // Reserve exactly `truncateLines` lines so the height is predictable and
-    // side-by-side testers keep their toolbars aligned, then clip the overflow.
-    height: shouldTruncate ? `${size * lineHeight * truncateLines}px` : 'auto',
-    overflow: shouldTruncate ? 'hidden' : 'visible',
-    ...(ellipsis && {
-      display: '-webkit-box',
-      WebkitBoxOrient: 'vertical',
-      WebkitLineClamp: truncateLines
+    ...(shouldTruncate ? {
+      // Cap each column at `truncateLines` lines. `max-height` (not `height`)
+      // lets shorter paragraphs collapse to their content instead of padding
+      // out to N lines of whitespace. Columns send the clipped overflow
+      // sideways (into off-screen columns) rather than below, so the last
+      // visible line of every column is never partially covered by the next
+      // one. That lets the symmetric `lineOverflowEm` padding fully reveal the
+      // first line's ascenders/accents and the last line's descenders at any
+      // line-height; the negative margins cancel that padding in layout so a
+      // collapsed paragraph still occupies exactly its line count.
+      //
+      // Everything is in `em` so it tracks the rendered font-size (including
+      // the mobile `--type-tester--adjustment`); the `+ 2px` is slack that
+      // keeps sub-pixel rounding from dropping the Nth line (the extra never
+      // reveals line N+1 because that line is clipped out to the side).
+      boxSizing: 'border-box',
+      maxHeight: `calc(${truncateLines * lineHeight + 2 * lineOverflowEm}em + 2px)`,
+      paddingTop: `${lineOverflowEm}em`,
+      paddingBottom: `${lineOverflowEm}em`,
+      paddingLeft: sideBearing,
+      paddingRight: sideBearing,
+      marginTop: `${-lineOverflowEm}em`,
+      marginBottom: `${-lineOverflowEm}em`,
+      overflow: 'hidden',
+      // Fill each column to its full N lines before spilling to the next, and
+      // allow a final column with a single line — otherwise the default
+      // `widows: 2` / `column-fill: balance` rebalance a 4-line paragraph into
+      // two columns of 2, showing N−1 lines instead of N.
+      columnFill: 'auto',
+      widows: 1,
+      orphans: 1,
+      ...(columnStyle ?? {
+        columnCount: 1
+      })
+    } : {
+      height: 'auto',
+      overflow: 'visible',
+      ...columnStyle
     }),
     fontFeatureSettings,
-    marginRight: alignment !== 'right' ? -sideBuffer : 0,
-    marginLeft: alignment === 'right' ? -sideBuffer : 0,
+    marginRight: `calc(${alignment !== 'right' ? -sideBuffer : 0}px - ${sideBearing})`,
+    marginLeft: `calc(${alignment === 'right' ? -sideBuffer : 0}px - ${sideBearing})`,
     letterSpacing: `${letterSpacing}em`,
     fontVariationSettings,
-    textAlign: alignment,
-    ...(columns && {
-      columnCount: columns.count,
-      columnWidth: columns.width,
-      columnGap: columns.gap
-    })
+    textAlign: alignment
   };
   return {
     ref,

package/dist/components/elements/StoreModalUnifiedCheckout.js

@@ -75,6 +75,7 @@ import StripeLogo from '../StripeLogo.js';
 import { Check, X } from '../Icons/index.js';
 import ConfigContext from '../ConfigContext.js';
 import { Price } from '../Price/index.js';
+import { sendOrderTracking } from '../Cart/orderTracking.js';
 
 /* const LICENSEE_REQUIRED_FIELDS = ['organization', 'country'] as (keyof Identity)[]; */
 
@@ -274,6 +275,13 @@ export default function StoreModalUnifiedCheckout(_ref2) {
     }));
   }, [setLicenseeIdentity]);
   const environment = useRelayEnvironment();
+
+  // Capture analytics consent + attribution on the order for the purchase
+  // event the server emits on completion (from a Stripe webhook, where no
+  // browser context exists).
+  useEffect(() => {
+    sendOrderTracking(environment);
+  }, [environment]);
   const [error, setError] = useState(null);
   const [errorsObject, setErrorsObject] = useState(null);
   const [customerErrorsObject, setCustomerErrorsObject] = useState(null);

package/dist/components/useFontStyle.d.ts

@@ -3,8 +3,15 @@ import { useFontStyle_fontStyle$key } from '../__generated__/useFontStyle_fontSt
 interface UseFontStyle_props {
     fontStyle: useFontStyle_fontStyle$key | null | undefined;
 }
+export type VerticalMetrics = {
+    readonly unitsPerEm: number;
+    readonly ascender: number;
+    readonly descender: number;
+    readonly lineGap: number | null;
+};
 declare const useFontStyle: ({ fontStyle: fontStyleKey, }: UseFontStyle_props) => {
     style: React.CSSProperties;
     loaded: boolean;
+    verticalMetrics: VerticalMetrics | null;
 };
 export default useFontStyle;

package/dist/components/useFontStyle.js

@@ -45,7 +45,8 @@ const useFontStyle = _ref => {
   };
   return {
     style: cssStyle,
-    loaded
+    loaded,
+    verticalMetrics: verticalMetrics ?? null
   };
 };
 export default useFontStyle;

package/dist/next/config.d.ts

@@ -0,0 +1,41 @@
+interface RouteHas {
+    type: 'header' | 'query' | 'cookie' | 'host';
+    key?: string;
+    value?: string;
+}
+interface Rewrite {
+    source: string;
+    destination: string;
+    has?: RouteHas[];
+    missing?: RouteHas[];
+}
+interface RewriteGroups {
+    beforeFiles: Rewrite[];
+    afterFiles: Rewrite[];
+    fallback: Rewrite[];
+}
+type RewritesResult = Rewrite[] | Partial<RewriteGroups>;
+interface NextConfigLike {
+    rewrites?: () => Promise<RewritesResult> | RewritesResult;
+    images?: {
+        remotePatterns?: unknown[];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export declare function tenantRewrites(): Rewrite[];
+export declare function withFontdue<C extends NextConfigLike>(nextConfig?: C): C & {
+    rewrites(): Promise<RewriteGroups>;
+    images: {
+        remotePatterns: unknown[];
+        dangerouslyAllowSVG: boolean;
+        loader: "custom";
+        loaderFile: string;
+    } | {
+        remotePatterns: unknown[];
+        dangerouslyAllowSVG: boolean;
+        unoptimized: boolean;
+    };
+    htmlLimitedBots: RegExp;
+};
+export {};

package/dist/next/config.js

@@ -0,0 +1,193 @@
+// withFontdue(nextConfig): next.config wrapper that installs everything a
+// Fontdue storefront needs — host→path tenant rewrites, image settings, and
+// workarounds for Next behaviors that would otherwise break Fontdue pages.
+// Import it from next.config.mjs (this package is ESM):
+//
+//   import { withFontdue } from 'fontdue-js/next/config';
+//   export default withFontdue({ /* your config */ });
+//
+// This module is evaluated at config-load time, so it must not import React,
+// Relay, or anything else from the component tree.
+
+import { existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// The tenant rewrites only make sense when the app routes live under the
+// /[domain]/... tree. A single-tenant app with a flat tree (the ejected
+// fontdue/example-next shape) routes normally and needs none of them.
+function hasDomainTree() {
+  return ['src/app/[domain]', 'app/[domain]'].some(dir => existsSync(join(process.cwd(), dir)));
+}
+
+// Minimal structural types so this module doesn't need `next` installed to
+// type-check; the shapes match next/dist/lib/load-custom-routes.
+
+// Every page lives under the /[domain]/... route tree so Next renders and
+// caches each tenant's pages independently. These rewrites turn the request's
+// host into that leading path segment:
+//
+//   acme.fontdue.com/fonts/foo  →  /acme.fontdue.com/fonts/foo (internal)
+//
+// In single-tenant mode the domain is constant (from NEXT_PUBLIC_FONTDUE_URL)
+// so the app behaves exactly like a plain single-site Next app.
+//
+// This is done with config rewrites rather than middleware on purpose:
+// middleware rewrites bypass the ISR page cache on self-hosted next start,
+// turning every request into a full render. beforeFiles rewrites go through
+// the normal routing layer and keep per-tenant ISR working. (beforeFiles also
+// runs before app routes are matched, so the internal /[domain] paths can't
+// be reached directly with a mismatching Host — /evil.com on acme's domain
+// becomes /acme.fontdue.com/evil.com, which 404s.)
+//
+// X-Forwarded-Host (set by the Fontdue proxy in front of this service) wins
+// over Host. The hostname charset is constrained in the patterns; anything
+// else falls through to a 404.
+//
+// beforeFiles rules CHAIN: each rule is evaluated in order against the
+// already-rewritten path, so a rewrite must produce a path no later rule can
+// match. Tenant domains always contain a dot, so the catch-all path rule
+// refuses any path whose first segment contains a dot — that makes the
+// rewritten /acme.fontdue.com/... inert. robots.txt and sitemap.xml (dotted
+// first segments we DO want to serve) get their own explicit rules, which run
+// first. Side effect: a page slug containing a dot can't be routed at the
+// top level.
+const TENANT_HOST = '(?<tenant>[a-zA-Z0-9][a-zA-Z0-9.-]*)';
+const DOTLESS_PATH = '/:path((?!api/|_next/|favicon\\.ico)(?![^/]*\\.[^/]*(?:/|$)).*)';
+
+// One rule set rewriting onto `dest` (either a fixed /domain or the /:tenant
+// capture from `has`). `conditions` is {has?, missing?}.
+function rewriteRules(dest) {
+  let conditions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  return [{
+    source: '/',
+    destination: dest,
+    ...conditions
+  }, {
+    source: '/robots.txt',
+    destination: `${dest}/robots.txt`,
+    ...conditions
+  }, {
+    source: '/sitemap.xml',
+    destination: `${dest}/sitemap.xml`,
+    ...conditions
+  }, {
+    source: DOTLESS_PATH,
+    destination: `${dest}/:path`,
+    ...conditions
+  }];
+}
+export function tenantRewrites() {
+  const fontdueUrl = process.env.NEXT_PUBLIC_FONTDUE_URL;
+  const isMultiTenant = process.env.FONTDUE_MULTI_TENANT === '1';
+  if (!isMultiTenant) {
+    return rewriteRules(`/${new URL(fontdueUrl).host}`);
+  }
+  const forwardedHost = {
+    type: 'header',
+    key: 'x-forwarded-host',
+    value: `${TENANT_HOST}(:.*)?`
+  };
+  const noForwardedHost = {
+    type: 'header',
+    key: 'x-forwarded-host'
+  };
+  const host = {
+    type: 'host',
+    value: TENANT_HOST
+  };
+  return [...rewriteRules('/:tenant', {
+    has: [forwardedHost]
+  }),
+  // Host-based rules only apply when X-Forwarded-Host is absent, so the
+  // two sets can't both rewrite one request.
+  ...rewriteRules('/:tenant', {
+    has: [host],
+    missing: [noForwardedHost]
+  })];
+}
+async function resolveRewrites(rewrites) {
+  const result = (await (rewrites === null || rewrites === void 0 ? void 0 : rewrites())) ?? [];
+  // A plain array from rewrites() is afterFiles, per Next's contract.
+  if (Array.isArray(result)) {
+    return {
+      beforeFiles: [],
+      afterFiles: result,
+      fallback: []
+    };
+  }
+  return {
+    beforeFiles: result.beforeFiles ?? [],
+    afterFiles: result.afterFiles ?? [],
+    fallback: result.fallback ?? []
+  };
+}
+export function withFontdue() {
+  let nextConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const fontdueUrl = process.env.NEXT_PUBLIC_FONTDUE_URL;
+  const isMultiTenant = process.env.FONTDUE_MULTI_TENANT === '1';
+  if (!isMultiTenant && !fontdueUrl) {
+    throw new Error('Set NEXT_PUBLIC_FONTDUE_URL (single-tenant) or FONTDUE_MULTI_TENANT=1 (multi-tenant).');
+  }
+  const domainTree = hasDomainTree();
+  if (isMultiTenant && !domainTree) {
+    throw new Error('FONTDUE_MULTI_TENANT=1 requires the app routes to live under src/app/[domain]/ (one cache entry per domain).');
+  }
+  const userImages = nextConfig.images ?? {};
+  return {
+    ...nextConfig,
+    async rewrites() {
+      const user = await resolveRewrites(nextConfig.rewrites);
+      if (!domainTree) return user;
+      return {
+        // App rules run first, against the public (pre-tenant) path; because
+        // beforeFiles rules chain, a dotless path they produce is then
+        // prefixed by the tenant rules like any direct request. afterFiles
+        // and fallback rules run after the tenant prefix is applied, so
+        // their sources must match the internal /[domain]/... form.
+        beforeFiles: [...user.beforeFiles, ...tenantRewrites()],
+        afterFiles: user.afterFiles,
+        fallback: user.fallback
+      };
+    },
+    images: {
+      // With a Cloudflare image transformation host configured, optimization
+      // moves to its edge (image-loader.ts) and the in-process optimizer —
+      // and sharp — stay out of the deployment entirely. The host must be in
+      // the env at build time (the loader is inlined into the client bundle)
+      // as well as at serve time (this config runs again under next start).
+      //
+      // Without one, in multi-tenant dev the GraphQL origin is typically a
+      // container or tunnel from which tenant hostnames don't resolve
+      // publicly, so the optimizer can't fetch the originals — serve them
+      // unoptimized there.
+      ...(process.env.NEXT_PUBLIC_FONTDUE_IMAGE_HOST ? {
+        loader: 'custom',
+        // Next resolves loaderFile against the project root and rejects
+        // absolute paths, so point into this package relative to cwd.
+        loaderFile: relative(process.cwd(), fileURLToPath(new URL('./image-loader.js', import.meta.url)))
+      } : {
+        unoptimized: isMultiTenant && process.env.NODE_ENV !== 'production'
+      }),
+      dangerouslyAllowSVG: true,
+      ...userImages,
+      remotePatterns: [...(fontdueUrl ? [{
+        protocol: 'https',
+        hostname: new URL(fontdueUrl).hostname
+      }] : []), {
+        protocol: 'https',
+        hostname: '*.fontdue.com'
+      },
+      // Multi-tenant: logos and images can live on any tenant custom
+      // domain. The URLs all come from the Fontdue CMS, not user input.
+      ...(isMultiTenant ? [{
+        protocol: 'https',
+        hostname: '**'
+      }] : []), ...(userImages.remotePatterns ?? [])]
+    },
+    // Treat every user agent as HTML-limited so metadata rendering blocks
+    // the response. Streamed metadata locks in a 200 status before
+    // generateMetadata's notFound() can produce a real 404.
+    htmlLimitedBots: nextConfig.htmlLimitedBots ?? /.*/
+  };
+}

package/dist/next/image-loader.d.ts

@@ -0,0 +1,7 @@
+interface ImageLoaderProps {
+    src: string;
+    width: number;
+    quality?: number;
+}
+export default function fontdueImageLoader({ src, width, quality, }: ImageLoaderProps): string;
+export {};

package/dist/next/image-loader.js

@@ -0,0 +1,39 @@
+// Custom next/image loader that serves images through a Cloudflare image
+// transformation host (developers.cloudflare.com/images/transform-images)
+// instead of the in-process Next optimizer, so the deployment needs neither
+// the /_next/image endpoint nor sharp. withFontdue activates it when
+// NEXT_PUBLIC_FONTDUE_IMAGE_HOST is set; see config.ts.
+//
+// NEXT_PUBLIC_FONTDUE_IMAGE_ORIGINS (comma-separated hostnames) should
+// mirror the transformation host's allowed-origins list. Sources on other
+// hosts — e.g. the /logo endpoint a site serves from its own (possibly
+// customer-owned) domain, which can't be allowlisted — are served as-is
+// rather than as transform URLs Cloudflare would refuse (ERROR 9401).
+//
+// Next bundles this file into the client build and inlines the NEXT_PUBLIC_
+// reads at build time, so it must stay dependency-free, and the variables
+// have to be present when `next build` runs (not just at serve time).
+
+function transformable(src) {
+  const origins = process.env.NEXT_PUBLIC_FONTDUE_IMAGE_ORIGINS;
+  if (!origins) return true;
+  let hostname;
+  try {
+    hostname = new URL(src).hostname;
+  } catch {
+    return false;
+  }
+  return origins.split(',').some(origin => origin.trim() === hostname);
+}
+export default function fontdueImageLoader(_ref) {
+  let {
+    src,
+    width,
+    quality
+  } = _ref;
+  const host = process.env.NEXT_PUBLIC_FONTDUE_IMAGE_HOST;
+  // No transform host, a local asset it couldn't fetch, or a source outside
+  // its allowed origins: serve the original, like `unoptimized`.
+  if (!host || src.startsWith('/') || !transformable(src)) return src;
+  return `https://${host}/cdn-cgi/image/width=${width},quality=${quality ?? 75},format=auto/${src}`;
+}

package/dist/next/index.d.ts

@@ -0,0 +1,2 @@
+export { isMultiTenant, isValidDomain, fontdueEndpoint, fontdueServerConfig, configureFontdueRender, prepareFontdueRender, currentFontdueEndpoint, generateStaticParams, type FontdueEndpoint, } from './tenant.js';
+export { setFontdueServerConfig, getFontdueServerConfig, type FontdueServerConfig, } from '../relay/serverConfig.js';

package/dist/next/index.js

@@ -0,0 +1,10 @@
+// Server-side entrypoint for Next.js apps (the App Router / RSC adapter).
+// The config-time wrapper lives in 'fontdue-js/next/config' and the deploy
+// hook route handler in 'fontdue-js/next/revalidate'.
+
+export { isMultiTenant, isValidDomain, fontdueEndpoint, fontdueServerConfig, configureFontdueRender, prepareFontdueRender, currentFontdueEndpoint, generateStaticParams } from './tenant.js';
+
+// The per-render config store consumed by fontdue-js's own server-side
+// fetches. configureFontdueRender covers the common case; these are exported
+// for apps that need to set or inspect the config directly.
+export { setFontdueServerConfig, getFontdueServerConfig } from '../relay/serverConfig.js';

package/dist/next/revalidate.d.ts

@@ -0,0 +1 @@
+export declare function POST(request: Request): Promise<Response>;

package/dist/next/revalidate.js

@@ -0,0 +1,37 @@
+// Route handler for Fontdue's deploy hook: re-export it from
+// app/api/revalidate/route.ts:
+//
+//   export { POST } from 'fontdue-js/next/revalidate';
+//
+// Fontdue calls it when a site's content changes. Multi-tenant deployments
+// receive the tenant in the URL, e.g.
+//   POST /api/revalidate?domain=acme.fontdue.com
+// and only that tenant's cache is purged (pages and embed data share the
+// per-domain tag — see fontdueEndpoint/fontdueServerConfig in ./tenant).
+// Single-tenant deployments use the parameterless form and purge everything
+// carrying the 'graphql' tag.
+
+import { revalidateTag } from 'next/cache';
+import { isMultiTenant, isValidDomain } from './tenant.js';
+export async function POST(request) {
+  var _URL$searchParams$get;
+  const domain = (_URL$searchParams$get = new URL(request.url).searchParams.get('domain')) === null || _URL$searchParams$get === void 0 ? void 0 : _URL$searchParams$get.toLowerCase();
+  if (isMultiTenant) {
+    if (!domain || !isValidDomain(domain)) {
+      return Response.json({
+        revalidated: false,
+        error: 'Missing or invalid ?domain='
+      }, {
+        status: 400
+      });
+    }
+    revalidateTag(`graphql:${domain}`);
+  } else {
+    revalidateTag('graphql');
+  }
+  return Response.json({
+    revalidated: true,
+    domain,
+    now: Date.now()
+  });
+}

package/dist/next/tenant.d.ts

@@ -0,0 +1,26 @@
+import { type FontdueServerConfig } from '../relay/serverConfig.js';
+export declare const isMultiTenant: boolean;
+export declare function isValidDomain(domain: string): boolean;
+export interface FontdueEndpoint {
+    /** The site domain this endpoint resolves. */
+    domain: string;
+    /** Base URL the app's own GraphQL fetches should target. */
+    origin: string;
+    /** Headers the Fontdue server needs to resolve the tenant. */
+    headers: Record<string, string>;
+    /**
+     * Cache tags for the app's own fetch calls (pass as `next: { tags }`), so
+     * the revalidate handler (see ./revalidate) can purge one site at a time.
+     */
+    tags: string[];
+}
+export declare function fontdueEndpoint(domain: string): FontdueEndpoint;
+export declare function fontdueServerConfig(domain: string): FontdueServerConfig;
+export declare function configureFontdueRender(domain: string): FontdueEndpoint | null;
+interface RenderProps {
+    params: Promise<Record<string, string | string[] | undefined>>;
+}
+export declare function prepareFontdueRender(props: RenderProps): Promise<FontdueEndpoint>;
+export declare function currentFontdueEndpoint(): FontdueEndpoint;
+export declare function generateStaticParams(): Promise<never[]>;
+export {};