fontdue-js 2.22.3 → 2.23.0

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Store } from 'redux';
+import { Config } from '../ConfigContext.js';
+import { FontdueAction, FontdueState } from '../../reducer.js';
+import { Components } from '../ComponentsContext.js';
+export declare function EnsureFontdueContext({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export interface FontdueContextProvider_props {
+    children?: React.ReactNode;
+    url?: string;
+    stripeIntegration?: 'card-element' | 'dynamic';
+    config?: Config;
+    components?: Components;
+    store?: Store<FontdueState, FontdueAction>;
+}
+export default function FontdueContextProvider({ children, url, stripeIntegration, config, components, store, }: FontdueContextProvider_props): React.JSX.Element;

package/dist/components/FontdueContextProvider/index.js

@@ -0,0 +1,108 @@
+'use client';
+
+import React, { Suspense, createContext, useContext, useRef } from 'react';
+import { Provider } from 'react-redux';
+import { RelayEnvironmentProvider } from 'react-relay';
+import { useCurrentEnvironment } from '../../relay/environment.js';
+import ConfigContext, { makeConfig } from '../ConfigContext.js';
+import { createDefaultStore } from '../../reducer.js';
+import ComponentsContext from '../ComponentsContext.js';
+import UrlContext from '../UrlContext.js';
+import { setCorsModalEnabled } from '../../corsError.js';
+
+// Marker context used by self-wrapping components to detect a parent
+// FontdueContextProvider/FontdueProvider. When the marker is `true`, a
+// self-wrapping component skips its inner FontdueContextProvider so the
+// outer config/url/store/relay-env flow through. Internal — do not export
+// from the package.
+const FontdueContextMarker = /*#__PURE__*/createContext(false);
+
+// Wraps `children` in `FontdueContextProvider` only when no parent
+// FontdueContextProvider/FontdueProvider is present. Self-wrapping components
+// (`<TypeTester>`, `<StoreModal>`, etc.) use this so they Just Work as
+// standalone islands while staying lightweight inside an outer
+// `<FontdueProvider>` tree.
+export function EnsureFontdueContext(_ref) {
+  let {
+    children
+  } = _ref;
+  const isInsideContext = useContext(FontdueContextMarker);
+  if (isInsideContext) return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+  return /*#__PURE__*/React.createElement(FontdueContextProvider, null, children);
+}
+const IS_SERVER = typeof window === typeof undefined;
+
+// === Multi-island state-sharing contract ===
+//
+// Frameworks that hydrate per-island (Astro, Vike, Qwik) mount one
+// `FontdueContextProvider` per fontdue-js component on the page. Each island
+// runs its own React reconciler and gets its own copy of every context, so
+// state that lives inside the component tree is duplicated — adding to the
+// cart in one island wouldn't update the CartButton in a different island.
+//
+// Any stateful client to be shared *across islands* (a Redux store, a Relay
+// Environment, or any future cache) must be a module-level singleton on the
+// client and per-render on the server. SSR has the opposite constraint: a
+// client-shared singleton would leak state between concurrent requests.
+//
+// The pattern (see also `relay/environment.ts → useCurrentEnvironment`):
+//
+//   let clientThing: Thing | null = null;
+//   function useSharedThing() {
+//     if (IS_SERVER) return createThing(); // per-render, no leakage
+//     if (clientThing == null) clientThing = createThing();
+//     return clientThing; // shared across islands
+//   }
+//
+// If you add a new context provider here that holds mutable client state,
+// follow this pattern. If it's purely deriving from props (no state), a
+// vanilla `Context.Provider` is fine — each island will compute the same
+// value.
+let clientStore = null;
+function useSharedStore(providedStore, config) {
+  const ref = useRef(null);
+  if (providedStore) return providedStore;
+  if (IS_SERVER) {
+    if (ref.current == null) ref.current = createDefaultStore(config);
+    return ref.current;
+  }
+  if (clientStore == null) clientStore = createDefaultStore(config);
+  return clientStore;
+}
+// Lightweight wrapper that sets up Fontdue's React contexts (Relay env,
+// Redux store, config, url, components) without rendering any aux UI.
+// `*Preloaded` self-wrapping components use this so they can stand alone
+// without claiming the page-level aux UI slot. Pages that need aux UI
+// (theme/test-mode/consent/tracking) wrap with `FontdueProvider` instead.
+export default function FontdueContextProvider(_ref2) {
+  let {
+    children,
+    url,
+    stripeIntegration,
+    config,
+    components,
+    store
+  } = _ref2;
+  const environment = useCurrentEnvironment({
+    url,
+    stripeIntegration
+  });
+  const configValue = makeConfig(config);
+  setCorsModalEnabled(configValue.corsErrorModal);
+  const sharedStore = useSharedStore(store, config);
+  return /*#__PURE__*/React.createElement(FontdueContextMarker.Provider, {
+    value: true
+  }, /*#__PURE__*/React.createElement(RelayEnvironmentProvider, {
+    environment: environment
+  }, /*#__PURE__*/React.createElement(Provider, {
+    store: sharedStore
+  }, /*#__PURE__*/React.createElement(Suspense, {
+    fallback: null
+  }, /*#__PURE__*/React.createElement(ConfigContext.Provider, {
+    value: configValue
+  }, /*#__PURE__*/React.createElement(UrlContext.Provider, {
+    value: url ?? (typeof process !== 'undefined' ? process.env.NEXT_PUBLIC_FONTDUE_URL : undefined) ?? ''
+  }, /*#__PURE__*/React.createElement(ComponentsContext.Provider, {
+    value: components ?? {}
+  }, children)))))));
+}

package/dist/components/FontdueContextProvider/index.server.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { FontdueContextProvider_props } from './index.js';
+export type { FontdueContextProvider_props } from './index.js';
+export default function FontdueContextProviderServer(props: FontdueContextProvider_props): Promise<React.JSX.Element>;

package/dist/components/FontdueContextProvider/index.server.js

@@ -0,0 +1,7 @@
+import React from 'react';
+import FontdueContextProvider from './index.js';
+// RSC entry. The client component does the work; this exists so the
+// `react-server` export condition resolves to a server-renderable file.
+export default async function FontdueContextProviderServer(props) {
+  return /*#__PURE__*/React.createElement(FontdueContextProvider, props);
+}

package/dist/components/Precart/index.js

@@ -81,7 +81,7 @@ const specFromLicense = license => {
   }
   return licenseOptionSpec;
 };
-_Precart_license2.default.hash && _Precart_license2.default.hash !== "0a642f10f28ca7d3857db23cf645895a" && console.error("The definition of 'Precart_license' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _Precart_license2.default;
+_Precart_license2.default.hash && _Precart_license2.default.hash !== "db49280bb01f8bbef6283c0d3fba99e1" && console.error("The definition of 'Precart_license' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _Precart_license2.default;
 function Precart(_ref3) {
   var _viewer$precart2, _collection$licenses3;
   let {
@@ -120,7 +120,7 @@ function Precart(_ref3) {
     });
   }, [environment]);
   const onSelectLicense = (id, checked) => {
-    var _collection$licenses;
+    var _collection$licenses, _license$excludedLice;
     const license = collection === null || collection === void 0 ? void 0 : (_collection$licenses = collection.licenses) === null || _collection$licenses === void 0 ? void 0 : _collection$licenses.find(node => node.id === id);
     if (!license) return;
     const licenseOptionSpec = specFromLicense(license);
@@ -128,7 +128,8 @@ function Precart(_ref3) {
       type: 'PRECART_TOGGLE_LICENSE',
       licenseId: id,
       checked,
-      licenseOptionSpec
+      licenseOptionSpec,
+      excludedLicenseIds: (_license$excludedLice = license.excludedLicenses) === null || _license$excludedLice === void 0 ? void 0 : _license$excludedLice.map(l => l.id)
     });
   };
   const onSelectLicenseOption = (licenseId, variableId, optionId) => {
@@ -217,10 +218,14 @@ function Precart(_ref3) {
   }, [precartOpen]);
   (0, _react.useEffect)(() => {
     var _collection$licenses2;
-    collection === null || collection === void 0 ? void 0 : (_collection$licenses2 = collection.licenses) === null || _collection$licenses2 === void 0 ? void 0 : _collection$licenses2.filter(license => license.defaultSelected).map(specFromLicense).forEach(spec => dispatch({
-      type: 'PRECART_SELECT_LICENSE',
-      licenseOptionSpec: spec
-    }));
+    collection === null || collection === void 0 ? void 0 : (_collection$licenses2 = collection.licenses) === null || _collection$licenses2 === void 0 ? void 0 : _collection$licenses2.filter(license => license.defaultSelected).forEach(license => {
+      var _license$excludedLice2;
+      return dispatch({
+        type: 'PRECART_SELECT_LICENSE',
+        licenseOptionSpec: specFromLicense(license),
+        excludedLicenseIds: (_license$excludedLice2 = license.excludedLicenses) === null || _license$excludedLice2 === void 0 ? void 0 : _license$excludedLice2.map(l => l.id)
+      });
+    });
   }, []);
   function renderConfirmingModal(subtotal) {
     var _viewer$precart3, _viewer$precart3$skus;

package/dist/components/StoreModal/StoreModalIndex.js

@@ -15,7 +15,7 @@ const StoreModalIndex = _ref => {
   let {
     prepared
   } = _ref;
-  const data = (0, _reactRelay.usePreloadedQuery)((_StoreModalIndexQuery2.default.hash && _StoreModalIndexQuery2.default.hash !== "300b462c41a951b4f94c4b8da7a6821f" && console.error("The definition of 'StoreModalIndexQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _StoreModalIndexQuery2.default), prepared.indexQuery);
+  const data = (0, _reactRelay.usePreloadedQuery)((_StoreModalIndexQuery2.default.hash && _StoreModalIndexQuery2.default.hash !== "099c77808b41054885365ebe3eda03c8" && console.error("The definition of 'StoreModalIndexQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _StoreModalIndexQuery2.default), prepared.indexQuery);
   const viewer = data.viewer;
   const edges = (viewer === null || viewer === void 0 ? void 0 : (_viewer$rootCollectio = viewer.rootCollections) === null || _viewer$rootCollectio === void 0 ? void 0 : _viewer$rootCollectio.edges) ?? [];
   return /*#__PURE__*/_react.default.createElement(_StoreModalPageContainer.default, null, {

package/dist/components/StoreModalProductLicenseSelection/StoreModalProductLicense.js

@@ -42,7 +42,7 @@ function StoreModalProduceLicense(_ref) {
   let {
     license: licenseKey
   } = _ref;
-  const license = (0, _reactRelay.useFragment)((_StoreModalProductLicense_license2.default.hash && _StoreModalProductLicense_license2.default.hash !== "5729815aeedac2b8ea39eaab0a986b48" && console.error("The definition of 'StoreModalProductLicense_license' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _StoreModalProductLicense_license2.default), licenseKey);
+  const license = (0, _reactRelay.useFragment)((_StoreModalProductLicense_license2.default.hash && _StoreModalProductLicense_license2.default.hash !== "87cd41e76dcd8952d7096940a383b9f3" && console.error("The definition of 'StoreModalProductLicense_license' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _StoreModalProductLicense_license2.default), licenseKey);
   const licenseOptions = (0, _reactRedux.useSelector)(state => state.licenseOptions);
   const selectedOptions = licenseOptions.find(_ref2 => {
     let {
@@ -53,11 +53,13 @@ function StoreModalProduceLicense(_ref) {
   const isSelected = Boolean(selectedOptions);
   const dispatch = (0, _reactRedux.useDispatch)();
   const handleSelectLicense = (0, _react.useCallback)(() => {
+    var _license$excludedLice;
     dispatch({
       type: 'PRECART_TOGGLE_LICENSE',
       licenseId: license.id,
       checked: !isSelected,
-      licenseOptionSpec: specFromLicense(license)
+      licenseOptionSpec: specFromLicense(license),
+      excludedLicenseIds: (_license$excludedLice = license.excludedLicenses) === null || _license$excludedLice === void 0 ? void 0 : _license$excludedLice.map(l => l.id)
     });
   }, [dispatch, license, isSelected]);
   const handleLicenseOptionChange = (0, _react.useCallback)(_ref3 => {
@@ -66,9 +68,11 @@ function StoreModalProduceLicense(_ref) {
       optionId
     } = _ref3;
     if (!isSelected) {
+      var _license$excludedLice2;
       dispatch({
         type: 'PRECART_SELECT_LICENSE',
-        licenseOptionSpec: specFromLicense(license)
+        licenseOptionSpec: specFromLicense(license),
+        excludedLicenseIds: (_license$excludedLice2 = license.excludedLicenses) === null || _license$excludedLice2 === void 0 ? void 0 : _license$excludedLice2.map(l => l.id)
       });
     }
     dispatch({
@@ -80,9 +84,11 @@ function StoreModalProduceLicense(_ref) {
   }, [dispatch, license, isSelected]);
   (0, _react.useEffect)(() => {
     if (license.defaultSelected) {
+      var _license$excludedLice3;
       dispatch({
         type: 'PRECART_SELECT_LICENSE',
-        licenseOptionSpec: specFromLicense(license)
+        licenseOptionSpec: specFromLicense(license),
+        excludedLicenseIds: (_license$excludedLice3 = license.excludedLicenses) === null || _license$excludedLice3 === void 0 ? void 0 : _license$excludedLice3.map(l => l.id)
       });
     }
   }, []);

package/dist/components/TypeTester/TypeTesterStandalone.preload.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
-import { LoadSerializableQueryOptions, SerializablePreloadedQuery } from '../../relay/loadSerializableQuery';
-import { TypeTesterStandaloneQuery } from '../../__generated__/TypeTesterStandaloneQuery.graphql';
-import { TypeTesterStandalonePreloadedQueryRenderer } from './TypeTesterStandalone';
+import { LoadSerializableQueryOptions, SerializablePreloadedQuery } from '../../relay/loadSerializableQuery.js';
+import { TypeTesterStandaloneQuery } from '../../__generated__/TypeTesterStandaloneQuery.graphql.js';
+import { TypeTesterStandalonePreloadedQueryRenderer } from './TypeTesterStandalone.js';
 export type TypeTesterPreloadedQuery = SerializablePreloadedQuery<TypeTesterStandaloneQuery>;
 export interface LoadTypeTesterQueryVariables {
     familyName: string;

package/dist/components/TypeTester/TypeTesterStandalone.preload.js

@@ -1,8 +1,8 @@
 import React from 'react';
-import loadSerializableQuery from '../../relay/loadSerializableQuery';
-import TypeTesterStandaloneQueryNode from '../../__generated__/TypeTesterStandaloneQuery.graphql';
-import FontdueProvider from '../FontdueProvider';
-import { TypeTesterStandalonePreloadedQueryRenderer } from './TypeTesterStandalone';
+import loadSerializableQuery from '../../relay/loadSerializableQuery.js';
+import TypeTesterStandaloneQueryNode from '../../__generated__/TypeTesterStandaloneQuery.graphql.js';
+import FontdueContextProvider from '../FontdueContextProvider/index.js';
+import { TypeTesterStandalonePreloadedQueryRenderer } from './TypeTesterStandalone.js';
 export async function loadTypeTesterQuery(variables, options) {
   return loadSerializableQuery(TypeTesterStandaloneQueryNode, {
     familyName: variables.familyName,
@@ -10,10 +10,11 @@ export async function loadTypeTesterQuery(variables, options) {
     selectable: variables.selectable ?? true
   }, options);
 }
-// Self-wraps with FontdueProvider so consumers don't need to. The provider
-// state is a module-level singleton under the hood, so multiple
-// TypeTesterPreloaded (or other *Preloaded) components on a page all share
-// one Relay env + Redux store + auxiliary UI.
+// Self-wraps with FontdueContextProvider so consumers don't need to wire up
+// Relay env / Redux store / contexts at the call site. Aux UI (theme,
+// test-mode banner, consent, tracking) is NOT rendered here — that belongs
+// to a single layout-level `<FontdueProvider>` per page. State is shared
+// across multiple preloaded components on a page via module-level singletons.
 export function TypeTesterPreloaded(props) {
-  return /*#__PURE__*/React.createElement(FontdueProvider, null, /*#__PURE__*/React.createElement(TypeTesterStandalonePreloadedQueryRenderer, props));
+  return /*#__PURE__*/React.createElement(FontdueContextProvider, null, /*#__PURE__*/React.createElement(TypeTesterStandalonePreloadedQueryRenderer, props));
 }

package/dist/config.d.ts

@@ -1,4 +1,5 @@
-export interface FontdueConfig {
+import type { Config } from './components/ConfigContext.js';
+export interface FontdueConfig extends Config {
     url?: string;
     stripeIntegration?: 'card-element' | 'dynamic';
 }

package/dist/config.js

@@ -1,14 +1,25 @@
 // Module-level global configuration. Consumers call `configure()` once at
-// app startup (e.g. Astro middleware, Next layout, Vite entry) and every
-// fontdue-js entry point reads defaults from here. Explicit options passed
-// to loadSerializableQuery / FontdueProvider still override.
+// app startup (Astro layout, Next layout, Vite entry) and every fontdue-js
+// entry point reads defaults from here.
+//
+// Precedence (low to high):
+//   1. Server admin config (from the tenant dashboard, fetched via Relay)
+//   2. configure({...})  — module-level code defaults
+//   3. <FontdueProvider config={...}>  — per-instance prop override
 //
 // Per-request isolation note: `configure` sets module-level state. That's
-// fine for single-tenant apps (one URL for the whole site). Multi-tenant
-// servers that switch URL per request should pass `url` explicitly to
-// loadSerializableQuery rather than rely on configure().
+// fine for single-tenant apps. Multi-tenant servers that switch URL per
+// request should pass `url` explicitly to loadSerializableQuery rather than
+// rely on configure().
+
+// Network-layer + UI config in one bag. UI fields come from `Config` (the
+// shape passed to ConfigContext); URL + stripeIntegration are network-layer.
 
 let current = {};
+
+// Shallow-merges with prior values. Calling `configure({tracking: {...}})`
+// replaces the whole `tracking` subtree; pass nested fields fully populated
+// when partial-updating.
 export function configure(opts) {
   current = {
     ...current,

package/dist/hooks/useResizeObserver.d.ts

@@ -0,0 +1,11 @@
+type ResizeObserverCtor = new (callback: ResizeObserverCallback) => {
+    observe: (target: Element) => void;
+    unobserve?: (target: Element) => void;
+    disconnect?: () => void;
+};
+export type UseResizeObserverOptions = {
+    polyfill?: ResizeObserverCtor | null;
+};
+export type UseResizeObserverCallback = (entry: ResizeObserverEntry, observer: ResizeObserver) => void;
+export default function useResizeObserver<T extends Element>(target: React.RefObject<T | null> | T | null, callback: UseResizeObserverCallback, options?: UseResizeObserverOptions): void;
+export {};

package/dist/hooks/useResizeObserver.js

@@ -0,0 +1,23 @@
+import { useEffect, useRef } from 'react';
+
+// Loose constructor type so the SSR no-op polyfills used as fallbacks (which
+// don't implement `disconnect`) still type-check.
+
+export default function useResizeObserver(target, callback) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useEffect(() => {
+    const element = target && 'current' in target ? target.current : target;
+    if (!element) return;
+    const Ctor = options.polyfill ?? (typeof ResizeObserver !== 'undefined' ? ResizeObserver : null);
+    if (!Ctor) return;
+    const observer = new Ctor(entries => {
+      for (const entry of entries) callbackRef.current(entry, observer);
+    });
+    observer.observe(element);
+    return () => {
+      if (observer.disconnect) observer.disconnect();else if (observer.unobserve) observer.unobserve(element);
+    };
+  }, [target, options.polyfill]);
+}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { configure, getConfig } from './config';
-export type { FontdueConfig } from './config';
+export { default as loadFontdueProviderQuery } from './loadFontdueProviderQuery.js';
+export type { FontdueProviderPreloadedQuery } from './loadFontdueProviderQuery.js';

package/dist/index.js

@@ -1 +1 @@
-export { configure, getConfig } from './config';
+export { default as loadFontdueProviderQuery } from './loadFontdueProviderQuery.js';

package/dist/loadFontdueProviderQuery.d.ts

@@ -0,0 +1,3 @@
+import type { FontdueProviderPreloadedQuery } from './components/FontdueProvider/index.js';
+export type { FontdueProviderPreloadedQuery };
+export default function loadFontdueProviderQuery(): Promise<FontdueProviderPreloadedQuery>;

package/dist/loadFontdueProviderQuery.js

@@ -0,0 +1,10 @@
+import loadSerializableQuery from './relay/loadSerializableQuery.js';
+import FontdueProviderQueryNode from './__generated__/FontdueProviderQuery.graphql.js';
+// Fetches the data aux UI (theme custom properties, test-mode flag) needs to
+// render synchronously on the server and on hydration. Pass the result to
+// `<FontdueProvider preloadedQuery={…}>` in your layout. Without it, aux UI
+// falls back to lazy-fetching on first client render — which causes a visible
+// theming flash because `ThemeConfig` injects CSS variables.
+export default async function loadFontdueProviderQuery() {
+  return loadSerializableQuery(FontdueProviderQueryNode, {});
+}

package/dist/reducer.d.ts

@@ -57,10 +57,12 @@ export type FontdueAction = {
     type: 'PRECART_TOGGLE_LICENSE';
     licenseId: string;
     licenseOptionSpec: LicenseOptionSpec;
+    excludedLicenseIds?: readonly string[];
     checked: boolean;
 } | {
     type: 'PRECART_SELECT_LICENSE';
     licenseOptionSpec: LicenseOptionSpec;
+    excludedLicenseIds?: readonly string[];
 } | {
     type: 'PRECART_SELECT_LICENSE_OPTION';
     licenseId: string;

package/dist/reducer.js

@@ -34,9 +34,11 @@ const selectLicense = (state, action) => {
   if (!(action.type === 'PRECART_SELECT_LICENSE' || action.type === 'PRECART_TOGGLE_LICENSE')) return state;
   const existingLicenseOption = state.licenseOptions.findIndex(option => option.licenseId === action.licenseOptionSpec.licenseId);
   if (existingLicenseOption >= 0) return state;
+  const excludedIds = action.excludedLicenseIds ?? [];
+  const filtered = excludedIds.length > 0 ? state.licenseOptions.filter(option => !excludedIds.includes(option.licenseId)) : state.licenseOptions;
   return {
     ...state,
-    licenseOptions: state.licenseOptions.concat(action.licenseOptionSpec)
+    licenseOptions: filtered.concat(action.licenseOptionSpec)
   };
 };
 const toggleLicense = (state, action) => {

package/dist/vite.d.ts

@@ -0,0 +1,2 @@
+import type { PluginOption } from 'vite';
+export default function fontdueJs(): PluginOption[];

package/dist/vite.js

@@ -0,0 +1,139 @@
+// Vite plugin that fixes the SSR-side CJS interop fontdue-js's deps need.
+//
+// fontdue-js itself is published as transpiled (not bundled) ESM. Its Relay
+// + draft-js + fbjs deps still ship as CJS using `module.exports = require(…)`
+// re-export shapes that Node's strict ESM-CJS interop (and Vite's dev SSR
+// module-runner) can't named-import from. Without help, `import { graphql }
+// from 'react-relay'` blows up at SSR time with `Named export 'graphql' not
+// found` or `module is not defined`.
+//
+// `vite-plugin-cjs-interop` is the canonical fix for this — referenced by the
+// Relay maintainers in https://github.com/facebook/relay/issues/4548. It
+// rewrites named imports of the listed packages to read from `.default` after
+// CJS load, which is what Node + Vite actually expose.
+//
+// Consumers wire it up like:
+//
+//   // vite.config.ts
+//   import fontdueJs from 'fontdue-js/vite';
+//   export default defineConfig({ plugins: [fontdueJs()] });
+//
+// Returned shape is structurally a Vite Plugin (or array of plugins).
+//
+// @ts-ignore — vite-plugin-cjs-interop has no bundled types but exports
+// cjsInterop at runtime.
+import { cjsInterop } from 'vite-plugin-cjs-interop';
+import { createRequire } from 'node:module';
+
+// Packages whose imports cjsInterop should rewrite to default-import +
+// destructure shape. Limit this to packages that genuinely ship as CJS-only
+// with `module.exports = require('./lib')` shapes that defeat named-import
+// resolution. React-redux is real ESM and must NOT be in this list — its
+// ESM build has true named exports.
+const CJS_DEPS = ['react-relay', 'relay-runtime', 'draft-js', 'fbjs'];
+
+// Packages to pre-bundle for the browser via Vite's optimizer. Pre-bundling
+// pulls a package's transitive deps into one esbuild output, which sidesteps
+// the cjs-module-lexer trap when an ESM package (react-redux) imports a CJS
+// transitive (use-sync-external-store). Without this, the browser dev path
+// fails with "does not provide an export named useSyncExternalStoreWithSelector".
+//
+// `react-google-recaptcha` and `@stripe/react-stripe-js` are pulled into the
+// StoreModal subtree (checkout flow). Both transitively import `prop-types`,
+// whose `module.exports = require('./factoryWithTypeCheckers')(...)` shape
+// hides exports behind a runtime call — cjs-module-lexer can't see them, so
+// the optimizer's auto-generated wrapper omits a `default` export. Including
+// the consumers + setting `needsInterop` on `prop-types` forces Vite to
+// synthesize a default export so `import PropTypes from 'prop-types'` resolves.
+const CLIENT_OPTIMIZE = [...CJS_DEPS, 'react-redux', 'react-google-recaptcha', '@stripe/react-stripe-js', 'prop-types',
+// Transitive deps that Vite would otherwise discover late, after fontdue-js
+// subpaths are first imported. Each late discovery triggers a re-optimize
+// and a new browserHash for `react`, which produces the dual-React bug
+// described above `getFontdueJsSubpaths`. Pinning them here keeps the
+// initial scan complete.
+'@sentry/react', '@stripe/stripe-js', 'react-error-boundary', 'redux'];
+const NEEDS_INTEROP = ['prop-types'];
+
+// Every public `fontdue-js/*` entry from package.json `exports`. Pre-including
+// them in `optimizeDeps` forces Vite to scan them on the first dev startup
+// instead of discovering them later when a route lazy-loads.
+//
+// Why this matters: when Vite finds a new dep mid-session it re-runs the
+// optimizer, which mints a new `?v=` browserHash for every dep chunk. Chunks
+// already loaded in the page keep their old `?v=` baked into their imports,
+// so a freshly-fetched chunk that imports `react?v=NEW` ends up coexisting
+// with the previously-loaded `react?v=OLD`. Two physical React modules in
+// the same page → two `ReactCurrentDispatcher`s → `useContext` returns null
+// → "Invalid hook call" on first navigation to an uncached route.
+//
+// Frameworks that lazy-load modules (RR7's route splitter, Astro's per-island
+// hydration) make this near-certain unless the optimizer sees the full set
+// up front. Vite's glob form (`fontdue-js/*`) walks the filesystem and gets
+// confused by our `exports`-mapped layout (the dist files don't sit at the
+// subpath names), so we read `exports` directly — that's the authoritative
+// list.
+function getFontdueJsSubpaths() {
+  const require = createRequire(import.meta.url);
+  const pkg = require('../package.json');
+  const out = [];
+  for (const key of Object.keys(pkg.exports ?? {})) {
+    if (!key.startsWith('./')) continue;
+    if (key.endsWith('.css')) continue;
+    if (key === './vite') continue;
+    out.push(`fontdue-js/${key.slice(2)}`);
+  }
+  return out;
+}
+export default function fontdueJs() {
+  const fontdueSubpaths = getFontdueJsSubpaths();
+  return [cjsInterop({
+    dependencies: CJS_DEPS
+  }), {
+    name: 'fontdue-js',
+    config() {
+      return {
+        // Pre-bundle the CJS-shaped deps via esbuild for the client
+        // bundle. Without this, Astro dev's browser pass tries to
+        // ESM-import `Environment` from `relay-runtime` and fails —
+        // its `module.exports = require('./lib/index.js')` shape can't
+        // be statically analyzed for named exports.
+        optimizeDeps: {
+          include: [...fontdueSubpaths, ...CLIENT_OPTIMIZE],
+          needsInterop: [...NEEDS_INTEROP]
+        },
+        // fbjs (transitive via draft-js) references Node's `global` at
+        // module init. Browsers don't define it, so the pre-bundled chunk
+        // throws `ReferenceError: global is not defined`. Aliasing
+        // `global` to `globalThis` at compile time covers both browser
+        // and SSR paths.
+        define: {
+          global: 'globalThis'
+        }
+      };
+    },
+    // Apply `noExternal` to every server-side Vite environment so
+    // fontdue-js source flows through Vite's transform pipeline and
+    // cjsInterop can rewrite its imports of CJS-shaped Relay/draft-js/
+    // fbjs. The legacy `ssr.noExternal` only covered the default `ssr`
+    // environment, so Astro 6's separate `prerender` build externalized
+    // fontdue-js and `import { graphql } from 'react-relay'` ran against
+    // unrewritten CJS at prerender time.
+    //
+    // `config.consumer` would be the principled check, but at
+    // `configEnvironment` time Vite hasn't populated it yet (undefined
+    // for ssr/prerender/client alike). Match by name instead:
+    //   - 'ssr':        default Vite SSR env (plain Vite SSR, RR7)
+    //   - 'prerender':  Astro 6's static-prerender env
+    // The `consumer` fallback is kept as future-proofing if a framework
+    // ever names its server env something else but does populate consumer.
+    configEnvironment(name, config) {
+      if (name === 'ssr' || name === 'prerender' || config.consumer === 'server') {
+        return {
+          resolve: {
+            noExternal: ['fontdue-js']
+          }
+        };
+      }
+    }
+  }];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fontdue-js",
-  "version": "2.22.3",
+  "version": "2.23.0",
   "scripts": {
     "build": "npm run relay && run-p build-js build-css build-ts",
     "build-js": "babel src --out-dir dist --extensions .ts,.tsx,.js,.jsx",

package/types/font-face-set.d.ts

@@ -0,0 +1,11 @@
+declare global {
+  interface FontFaceSet {
+    add(font: FontFace): FontFaceSet;
+    delete(font: FontFace): boolean;
+    clear(): void;
+    has(font: FontFace): boolean;
+    readonly size: number;
+  }
+}
+
+export {};

package/.nvmrc

@@ -1 +0,0 @@
-v14.13.1