fontdue-js 2.28.0 → 3.0.0-alpha10

package/dist/reducer.js

@@ -1,28 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.collectionSkuIdWithDiscount = void 0;
-Object.defineProperty(exports, "collectionSkuIdsDifferences", {
-  enumerable: true,
-  get: function () {
-    return _utils.collectionSkuIdsDifferences;
-  }
-});
-exports.createDefaultStore = createDefaultStore;
-exports.default = void 0;
-Object.defineProperty(exports, "isSelected", {
-  enumerable: true,
-  get: function () {
-    return _utils.isSelected;
-  }
-});
-var _productState = require("./components/Root/productState");
-var _redux = require("redux");
-var _reactRedux = require("react-redux");
-var _utils = require("./utils");
-var _ConfigContext = require("./components/ConfigContext");
+import { populateProductStateReducer } from './components/Root/productState.js';
+import { createStore } from 'redux';
+import { shallowEqual } from 'react-redux';
+import { collectionSkuIdsDifferences, collTransitivelyContainsSkuId, isSelected } from './utils.js';
+import { makeConfig } from './components/ConfigContext.js';
+export { collectionSkuIdsDifferences, isSelected };
 const unselectLicense = (state, action) => {
   if (!(action.type === 'PRECART_UNSELECT_LICENSE' || action.type === 'PRECART_TOGGLE_LICENSE')) return state;
   return {
@@ -80,8 +61,8 @@ const selectLicenseOption = (state, action) => {
     })
   };
 };
-const collectionSkuIdWithDiscount = (state, skuId) => {
-  const differences = (0, _utils.collectionSkuIdsDifferences)(state, skuId);
+export const collectionSkuIdWithDiscount = (state, skuId) => {
+  const differences = collectionSkuIdsDifferences(state, skuId);
   const collectionId = Object.keys(differences).filter(collSkuId => differences[collSkuId] <= state.skuPrices[skuId]).reduce((smallest, key) => {
     if (!smallest || differences[key] < differences[smallest]) return key;
     if (differences[key] === differences[smallest]) {
@@ -103,8 +84,7 @@ const collectionSkuIdWithDiscount = (state, skuId) => {
   if (collectionId) return [collectionId, differences[collectionId]];
   return [null, null];
 };
-exports.collectionSkuIdWithDiscount = collectionSkuIdWithDiscount;
-const selectedCollectionSkuIdContainingSkuId = (state, skuId) => Object.keys(state.selectedSkuIds).filter(id => state.selectedSkuIds[id] === true).find(selectedSkuId => (0, _utils.collTransitivelyContainsSkuId)(state.collectionStyleSkus, selectedSkuId, skuId));
+const selectedCollectionSkuIdContainingSkuId = (state, skuId) => Object.keys(state.selectedSkuIds).filter(id => state.selectedSkuIds[id] === true).find(selectedSkuId => collTransitivelyContainsSkuId(state.collectionStyleSkus, selectedSkuId, skuId));
 const setKeysFalse = (acc, key) => {
   acc[key] = false;
   return acc;
@@ -174,7 +154,7 @@ const unselectSkus = state => ({
 });
 const storeModalNavigate = (state, action) => {
   if (action.type !== 'STORE_MODAL_NAVIGATE') return state;
-  if (state.storeModalRoute.name === action.route && (0, _reactRedux.shallowEqual)(state.storeModalRoute.variables, action.variables)) {
+  if (state.storeModalRoute.name === action.route && shallowEqual(state.storeModalRoute.variables, action.variables)) {
     return state;
   }
   return {
@@ -217,7 +197,7 @@ const reducer = (state, action) => {
   if (!state) throw 'Reducer called without state';
   switch (action.type) {
     case 'POPULATE_PRODUCT_STATE':
-      return (0, _productState.populateProductStateReducer)(state, action);
+      return populateProductStateReducer(state, action);
     case 'PRECART_TOGGLE_LICENSE':
       return toggleLicense(state, action);
     case 'PRECART_UNSELECT_LICENSE':
@@ -267,8 +247,8 @@ const reducer = (state, action) => {
       return state;
   }
 };
-function createDefaultStore(config) {
-  const configValue = (0, _ConfigContext.makeConfig)(config);
+export function createDefaultStore(config) {
+  const configValue = makeConfig(config);
   const initialRoute = configValue.storeModal.hideAllCollections ? {
     name: 'cart'
   } : {
@@ -277,7 +257,7 @@ function createDefaultStore(config) {
       excludeTags: configValue.storeModal.indexExcludeTags
     }
   };
-  return (0, _redux.createStore)(reducer, {
+  return createStore(reducer, {
     selectedSkuIds: {},
     // { [skuId]: Boolean }
     licenseOptions: [],
@@ -293,5 +273,4 @@ function createDefaultStore(config) {
     licenseeIsBillingIdentity: null
   });
 }
-var _default = reducer;
-exports.default = _default;
+export default reducer;

package/dist/relay/environment.d.ts

@@ -1,4 +1,5 @@
 import { Environment, RequestParameters, QueryResponseCache, Variables, GraphQLResponse } from 'relay-runtime';
+export declare function createNetworkFetch(options?: CreateRelayEnvironmentOptions): (request: RequestParameters, variables: Variables) => Promise<GraphQLResponse>;
 export declare const networkFetch: (request: RequestParameters, variables: Variables) => Promise<GraphQLResponse>;
 export declare const responseCache: QueryResponseCache | null;
 interface CreateRelayEnvironmentOptions {

package/dist/relay/environment.js

@@ -1,46 +1,81 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createEnvironment = createEnvironment;
-exports.responseCache = exports.networkFetch = void 0;
-exports.useCurrentEnvironment = useCurrentEnvironment;
-var _react = require("react");
-var _relayRuntime = require("relay-runtime");
-var _corsError = require("../corsError");
-var _package = require("../../package.json");
-// @ts-ignore - JSON import
+import { Environment, Network, RecordSource, Store, QueryResponseCache } from 'relay-runtime';
+import { handlePossibleCorsError } from '../corsError.js';
+import { getFontdueServerConfig } from './serverConfig.js';
 
+// `__FONTDUE_JS_VERSION__` is replaced by an inline babel plugin
+// (defineVersionPlugin in .babelrc.cjs) with the literal package.json#version.
+const version = "3.0.0-alpha10";
 const IS_SERVER = typeof window === typeof undefined;
-const FONTDUE_URL = typeof process !== 'undefined' ? process.env.NEXT_PUBLIC_FONTDUE_URL : undefined;
-if (IS_SERVER && (FONTDUE_URL == null || FONTDUE_URL === '')) {
-  throw new Error('fontdue-js requires a Fontdue URL to be configured via environment variables on the server, please set a NEXT_PUBLIC_FONTDUE_URL');
+
+// Read env from either process.env (Node/Next.js) or import.meta.env (Vite/Astro).
+// Prefer the framework-agnostic FONTDUE_URL name; fall back to NEXT_PUBLIC_FONTDUE_URL
+// for backwards compatibility with existing Next.js integrations.
+function readEnv(name) {
+  if (typeof process !== 'undefined' && process.env) {
+    const v = process.env[name];
+    if (v != null && v !== '') return v;
+  }
+  try {
+    // @ts-ignore - import.meta.env is Vite/Astro-specific
+    const metaEnv = typeof import.meta !== 'undefined' ? import.meta.env : undefined;
+    if (metaEnv) {
+      const v = metaEnv[name] ?? metaEnv[`PUBLIC_${name}`] ?? metaEnv[`VITE_${name}`];
+      if (v != null && v !== '') return v;
+    }
+  } catch {}
+  return undefined;
 }
-const STRIPE_INTEGRATION = typeof process !== 'undefined' ? process.env.NEXT_PUBLIC_FONTDUE_STRIPE_INTEGRATION : undefined;
+
+// On Next.js client bundles, only LITERAL `process.env.NAME` accesses get
+// inlined at build time — `process.env[dynamicName]` stays as a runtime
+// lookup that returns undefined in the browser. Check literal references
+// first so existing Next.js consumers keep working without changes.
+const NEXT_PUBLIC_URL = typeof process !== 'undefined' && process.env ? process.env.NEXT_PUBLIC_FONTDUE_URL : undefined;
+const NEXT_PUBLIC_STRIPE = typeof process !== 'undefined' && process.env ? process.env.NEXT_PUBLIC_FONTDUE_STRIPE_INTEGRATION : undefined;
+const FONTDUE_URL = readEnv('FONTDUE_URL') ?? readEnv('NEXT_PUBLIC_FONTDUE_URL') ?? NEXT_PUBLIC_URL;
+const STRIPE_INTEGRATION = readEnv('FONTDUE_STRIPE_INTEGRATION') ?? readEnv('NEXT_PUBLIC_FONTDUE_STRIPE_INTEGRATION') ?? NEXT_PUBLIC_STRIPE;
 const CACHE_TTL = 10 * 1000; // 10 seconds, to resolve preloaded results
 
-function createNetworkFetch(options) {
+export function createNetworkFetch(options) {
   return async function networkFetch(request, variables) {
-    const url = (FONTDUE_URL && `${FONTDUE_URL}/graphql`) ?? ((options === null || options === void 0 ? void 0 : options.url) ?? '') + '/graphql';
+    // Per-render server config (set via setFontdueServerConfig or the
+    // FontdueProvider server entrypoint). Resolved per call, not per
+    // createNetworkFetch, because module-level fetchers outlive renders.
+    const serverConfig = IS_SERVER ? getFontdueServerConfig() : undefined;
+    const base = (options === null || options === void 0 ? void 0 : options.url) ?? (serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.url) ?? FONTDUE_URL;
+    if (IS_SERVER && (base == null || base === '')) {
+      throw new Error('fontdue-js: no Fontdue URL configured for server-side fetch. ' + 'Set FONTDUE_URL / PUBLIC_FONTDUE_URL / VITE_FONTDUE_URL in your environment, ' + 'pass `url` to loadSerializableQuery, or call setFontdueServerConfig ' + '(or render <FontdueProvider url=…>) earlier in the server render.');
+    }
+    const url = `${base ?? ''}/graphql`;
     for (let attempt = 0; attempt <= 2; attempt++) {
       try {
         const resp = await fetch(url + `?queryName=${request.name}`, {
           method: 'POST',
           credentials: 'include',
           headers: {
+            ...(serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.headers),
             Accept: 'application/json',
             'Content-Type': 'application/json',
-            'fontdue-stripe-integration': STRIPE_INTEGRATION ?? ((options === null || options === void 0 ? void 0 : options.stripeIntegration) || 'dynamic'),
-            'fontdue-client-version': _package.version
+            'fontdue-stripe-integration': (options === null || options === void 0 ? void 0 : options.stripeIntegration) ?? STRIPE_INTEGRATION ?? 'dynamic',
+            'fontdue-client-version': version
           },
           body: JSON.stringify({
             query: request.text,
             variables
           }),
+          // Server-side fetches are all site content (per-session data is
+          // fetched client-side only), so opt them into Next's data cache —
+          // without this, Next 15 treats them as no-store and silently makes
+          // every page fully dynamic. The tags below let the revalidate
+          // handler purge them when content changes. Inert outside Next:
+          // Node's fetch accepts and ignores this cache mode, and the
+          // browser path doesn't set it.
+          ...(IS_SERVER ? {
+            cache: 'force-cache'
+          } : {}),
           // @ts-ignore
           next: {
-            tags: ['graphql', `operation:${request.name}`]
+            tags: ['graphql', ...((serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.cacheTags) ?? []), `operation:${request.name}`]
           }
         });
         const json = await resp.json();
@@ -64,7 +99,7 @@ function createNetworkFetch(options) {
           await new Promise(resolve => setTimeout(resolve, 1000));
           continue;
         }
-        if ((0, _corsError.handlePossibleCorsError)(error, url)) {
+        if (handlePossibleCorsError(error, url)) {
           return {
             data: undefined,
             errors: [{
@@ -80,13 +115,11 @@ function createNetworkFetch(options) {
     throw new Error('Unexpected: exhausted retries');
   };
 }
-const networkFetch = createNetworkFetch();
-exports.networkFetch = networkFetch;
-const responseCache = IS_SERVER ? null : new _relayRuntime.QueryResponseCache({
+export const networkFetch = createNetworkFetch();
+export const responseCache = IS_SERVER ? null : new QueryResponseCache({
   size: 250,
   ttl: CACHE_TTL
 });
-exports.responseCache = responseCache;
 function createNetwork(options) {
   async function fetchResponse(params, variables, cacheConfig) {
     const isQuery = params.operationKind === 'query';
@@ -101,20 +134,27 @@ function createNetwork(options) {
     }
     return createNetworkFetch(options)(params, variables);
   }
-  const network = _relayRuntime.Network.create(fetchResponse);
+  const network = Network.create(fetchResponse);
   return network;
 }
-function createEnvironment(options) {
-  return new _relayRuntime.Environment({
+export function createEnvironment(options) {
+  return new Environment({
     network: createNetwork(options),
-    store: new _relayRuntime.Store(_relayRuntime.RecordSource.create()),
+    store: new Store(RecordSource.create()),
     isServer: IS_SERVER
   });
 }
-function useCurrentEnvironment(options) {
+
+// Client-side Relay environment is a module-level singleton so multiple
+// FontdueProviders on a page (e.g. one per Astro island) share cache and
+// data. Server-side stays per-render to avoid cross-request pollution.
+let clientEnvironment = null;
+export function useCurrentEnvironment(options) {
   if (IS_SERVER) {
     return createEnvironment(options);
   }
-  const environmentRef = (0, _react.useRef)(createEnvironment(options));
-  return environmentRef.current;
+  if (clientEnvironment == null) {
+    clientEnvironment = createEnvironment(options);
+  }
+  return clientEnvironment;
 }

package/dist/relay/loadSerializableQuery.d.ts

@@ -43,5 +43,7 @@ export interface SerializablePreloadedQuery<TQuery extends OperationType> {
 type RequireAllWithNull<T> = {
     [K in keyof T]-?: T[K] | null;
 };
-export default function loadSerializableQuery<TQuery extends OperationType>(query: GraphQLTaggedNode, variables: RequireAllWithNull<VariablesOf<TQuery>>): Promise<SerializablePreloadedQuery<TQuery>>;
+export default function loadSerializableQuery<TQuery extends OperationType>(query: GraphQLTaggedNode, variables: RequireAllWithNull<VariablesOf<TQuery>>, options?: {
+    url?: string;
+}): Promise<SerializablePreloadedQuery<TQuery>>;
 export {};

package/dist/relay/loadSerializableQuery.js

@@ -1,10 +1,5 @@
-"use strict";
+import { createNetworkFetch } from './environment.js';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = loadSerializableQuery;
-var _environment = require("./environment");
 /**
  * RELAY CACHE KEY NORMALIZATION
  *
@@ -45,9 +40,10 @@ var _environment = require("./environment");
 // Call into raw network fetch to get serializable GraphQL query response
 // This response will be sent to the client to "warm" the QueryResponseCache
 // to avoid the client fetches.
-async function loadSerializableQuery(query, variables) {
+export default async function loadSerializableQuery(query, variables, options) {
   if (!('params' in query)) throw new Error('Params not found in query, is it a fragment instead of a query?');
-  const response = await (0, _environment.networkFetch)(query.params, variables);
+  const fetcher = createNetworkFetch(options);
+  const response = await fetcher(query.params, variables);
   return {
     params: query.params,
     variables,

package/dist/relay/serverConfig.d.ts

@@ -0,0 +1,16 @@
+export interface FontdueServerConfig {
+    /** Base URL for server-side GraphQL fetches, e.g. https://acme.fontdue.com */
+    url?: string;
+    /** Extra headers sent with every server-side GraphQL fetch. */
+    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
+     * (currentFontdueEndpoint) can recover it.
+     */
+    domain?: string;
+}
+export declare function setFontdueServerConfig(config: FontdueServerConfig): void;
+export declare function getFontdueServerConfig(): FontdueServerConfig | undefined;

package/dist/relay/serverConfig.js

@@ -0,0 +1,38 @@
+// Per-render configuration for server-side GraphQL fetches.
+//
+// React Server Components have no context API, so a `<FontdueProvider url=…>`
+// prop cannot reach the nested server components that preload queries — the
+// prop historically only configured client-side fetches. What RSC does have
+// is React.cache(): a memoization store scoped to one server render pass and
+// shared by every server component in it. We use a single cache cell as a
+// render-scoped mutable slot: the host app (or the FontdueProvider server
+// entrypoint) writes the config early in the render, and every later
+// server-side fetch in the same pass reads it.
+//
+// Unlike AsyncLocalStorage-based approaches (e.g. Next's headers()), reading
+// this store does not opt the route into dynamic rendering, so static
+// generation and ISR keep working. Each render pass gets a fresh store, so
+// concurrent requests cannot leak config into each other.
+//
+// Caveat that callers must own: the write has to happen in the same render
+// pass, before the fetch. A provider in a layout covers full-page renders,
+// but an App Router soft navigation re-renders only the page segment — set
+// the config at the top of each page (or in a shared data helper every page
+// calls) when pages contain Fontdue components.
+//
+// Outside an RSC render (client bundles, SSR setups without React.cache
+// semantics) the slot degrades to a throwaway object: writes become no-ops
+// and the environment variables remain the configuration source.
+
+import * as React from 'react';
+const getSlot = typeof React.cache === 'function' ? React.cache(() => ({
+  current: undefined
+})) : () => ({
+  current: undefined
+});
+export function setFontdueServerConfig(config) {
+  getSlot().current = config;
+}
+export function getFontdueServerConfig() {
+  return getSlot().current;
+}

package/dist/relay/useSerializablePreloadedQuery.d.ts

@@ -1,4 +1,4 @@
 import { PreloadedQuery, PreloadFetchPolicy } from "react-relay";
-import { OperationType } from "relay-runtime";
-import { SerializablePreloadedQuery } from "./loadSerializableQuery";
-export default function useSerializablePreloadedQuery<TQuery extends OperationType>(preloadQuery: SerializablePreloadedQuery<TQuery>, fetchPolicy?: PreloadFetchPolicy): PreloadedQuery<TQuery>;
+import { GraphQLTaggedNode, OperationType } from "relay-runtime";
+import { SerializablePreloadedQuery } from "./loadSerializableQuery.js";
+export default function useSerializablePreloadedQuery<TQuery extends OperationType>(preloadQuery: SerializablePreloadedQuery<TQuery>, fetchPolicy?: PreloadFetchPolicy, query?: GraphQLTaggedNode): PreloadedQuery<TQuery>;

package/dist/relay/useSerializablePreloadedQuery.js

@@ -1,29 +1,33 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = useSerializablePreloadedQuery;
-var _react = require("react");
-var _reactRelay = require("react-relay");
-var _environment = require("./environment");
 // Convert preloaded query object (with raw GraphQL Response) into
 // Relay's PreloadedQuery.
 
-// This hook convert serializable preloaded query
-// into Relay's PreloadedQuery object.
-// It is also writes this serializable preloaded query
-// into QueryResponseCache, so we the network layer
-// can use these cache results when fetching data
-// in `usePreloadedQuery`.
-function useSerializablePreloadedQuery(
-//environment: IEnvironment,
-preloadQuery) {
+import { useMemo } from "react";
+import { useRelayEnvironment } from "react-relay";
+import { createOperationDescriptor, getRequest } from "relay-runtime";
+import { responseCache } from "./environment.js";
+// This hook converts a serializable preloaded query into Relay's PreloadedQuery
+// object. It primes Relay so that `usePreloadedQuery` resolves synchronously on
+// both server and client:
+//   - On the client, it warms the QueryResponseCache so network-layer lookups hit.
+//   - When a `query` tagged node is provided, it also commits the response
+//     payload directly into the environment's Store via `commitPayload`. This is
+//     required for SSR frameworks (Astro, Vite SSR, etc.) whose non-streaming
+//     `renderToString` needs the data available synchronously during render.
+export default function useSerializablePreloadedQuery(preloadQuery) {
   let fetchPolicy = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "store-or-network";
-  (0, _react.useMemo)(() => {
+  let query = arguments.length > 2 ? arguments[2] : undefined;
+  const environment = useRelayEnvironment();
+  useMemo(() => {
     writePreloadedQueryToCache(preloadQuery);
-  }, [preloadQuery]);
-  const environment = (0, _reactRelay.useRelayEnvironment)();
+    if (query != null) {
+      const response = preloadQuery.response;
+      const singular = Array.isArray(response) ? response[0] : response;
+      if ((singular === null || singular === void 0 ? void 0 : singular.data) != null) {
+        const operation = createOperationDescriptor(getRequest(query), preloadQuery.variables);
+        environment.commitPayload(operation, singular.data);
+      }
+    }
+  }, [preloadQuery, environment, query]);
   return {
     environment,
     fetchKey: preloadQuery.params.id ?? preloadQuery.params.cacheID,
@@ -40,5 +44,5 @@ preloadQuery) {
 function writePreloadedQueryToCache(preloadedQueryObject) {
   // @ts-ignore
   const cacheKey = preloadedQueryObject.params.id ?? preloadedQueryObject.params.cacheID;
-  _environment.responseCache === null || _environment.responseCache === void 0 ? void 0 : _environment.responseCache.set(cacheKey, preloadedQueryObject.variables, preloadedQueryObject.response);
+  responseCache === null || responseCache === void 0 ? void 0 : responseCache.set(cacheKey, preloadedQueryObject.variables, preloadedQueryObject.response);
 }

package/dist/retryImport.js

@@ -1,9 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = retryImport;
 /**
  * Wraps a dynamic import in retry logic.
  *
@@ -16,7 +10,7 @@ exports.default = retryImport;
  *
  * See: https://github.com/whatwg/html/issues/6768
  */
-function retryImport(load) {
+export default function retryImport(load) {
   let retries = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
   let delay = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;
   return load().catch(error => {

package/dist/scripts/updateUnicodeData.js

@@ -1,5 +1,3 @@
-"use strict";
-
 const https = require('https');
 const fs = require('fs');
 const path = require('path');

package/dist/utils.d.ts

@@ -1,5 +1,5 @@
-import { CollectionStyleSkus } from './components/Root/productState';
-import type { FontdueState } from './reducer';
+import { CollectionStyleSkus } from './components/Root/productState.js';
+import type { FontdueState } from './reducer.js';
 export declare const pluralize: (count: number, singular: string, plural?: string) => string;
 export declare function notEmpty<TValue>(value: TValue | null | undefined): value is TValue;
 export declare function kebabToCamel(str: string): string;

package/dist/utils.js

@@ -1,46 +1,32 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.compareVariableSettings = exports.collectionSkuIdsDifferences = exports.collTransitivelyContainsSkuId = exports.collContainsSkuId = void 0;
-exports.getFeatureGlyphs = getFeatureGlyphs;
-exports.isSelected = exports.inspect = void 0;
-exports.kebabToCamel = kebabToCamel;
-exports.notEmpty = notEmpty;
-exports.variableSettingsCSS = exports.variableInstanceSettings = exports.variableInstanceCSS = exports.pluralize = exports.parseCustomProperties = void 0;
-const pluralize = (count, singular, plural) => {
+export const pluralize = (count, singular, plural) => {
   if (count === 1) return `1 ${singular}`;
   if (!plural) return `${count} ${singular}s`;
   return `${count}\xa0${plural}`;
 };
-exports.pluralize = pluralize;
-function notEmpty(value) {
+export function notEmpty(value) {
   return value !== null && value !== undefined;
 }
-function kebabToCamel(str) {
+export function kebabToCamel(str) {
   return str.replace(/-([a-z])/g, function (g) {
     return g[1].toUpperCase();
   });
 }
 
 // where coll is a member of `collectionStyleSkus`;
-const collContainsSkuId = (coll, skuIdOrStyleId) => {
+export const collContainsSkuId = (coll, skuIdOrStyleId) => {
   if (!coll) return false;
   return coll.childrenSkuIds.indexOf(skuIdOrStyleId) >= 0 || coll.fontStyleSkuIds.indexOf(skuIdOrStyleId) >= 0 || coll.fontStyleIds.indexOf(skuIdOrStyleId) >= 0;
 };
 
 // Transitive containment check — walks the collection hierarchy to find
 // if a SKU is contained at any depth (e.g., collection bundle → family → bundle)
-exports.collContainsSkuId = collContainsSkuId;
-const collTransitivelyContainsSkuId = (collectionStyleSkus, collSkuId, skuIdOrStyleId) => {
+export const collTransitivelyContainsSkuId = (collectionStyleSkus, collSkuId, skuIdOrStyleId) => {
   const coll = collectionStyleSkus[collSkuId];
   if (!coll) return false;
   if (collContainsSkuId(coll, skuIdOrStyleId)) return true;
   return coll.childrenSkuIds.some(childSkuId => collTransitivelyContainsSkuId(collectionStyleSkus, childSkuId, skuIdOrStyleId));
 };
-exports.collTransitivelyContainsSkuId = collTransitivelyContainsSkuId;
-const isSelected = skuIdOrStyleId => state => {
+export const isSelected = skuIdOrStyleId => state => {
   if (!skuIdOrStyleId) return false;
   if (state.selectedSkuIds[skuIdOrStyleId] === true) return true;
   // get the collections that contain this skuId as a fontStyle or child
@@ -53,8 +39,7 @@ const isSelected = skuIdOrStyleId => state => {
 // find any collection ancestors that contain this skuId,
 // then for each collection, sum the price of selected skus,
 // and return the delta between the collection price and the sum.
-exports.isSelected = isSelected;
-const collectionSkuIdsDifferences = (state, skuId) => Object.keys(state.collectionStyleSkus).filter(collectionSkuId => {
+export const collectionSkuIdsDifferences = (state, skuId) => Object.keys(state.collectionStyleSkus).filter(collectionSkuId => {
   return skuId === collectionSkuId || collTransitivelyContainsSkuId(state.collectionStyleSkus, collectionSkuId, skuId);
 }).reduce((acc, collectionSkuId) => {
   const selectedSkuIdsInColl = Object.keys(state.selectedSkuIds).filter(selectedSkuId => state.selectedSkuIds[selectedSkuId] === true && collTransitivelyContainsSkuId(state.collectionStyleSkus, collectionSkuId, selectedSkuId));
@@ -62,8 +47,7 @@ const collectionSkuIdsDifferences = (state, skuId) => Object.keys(state.collecti
   acc[collectionSkuId] = (state.skuPrices[collectionSkuId] ?? 0) - sumOfSelectedSkuIdsInColl;
   return acc;
 }, {});
-exports.collectionSkuIdsDifferences = collectionSkuIdsDifferences;
-const variableInstanceSettings = instance => instance === null || instance === void 0 ? void 0 : instance.coordinates.reduce((acc, _ref) => {
+export const variableInstanceSettings = instance => instance === null || instance === void 0 ? void 0 : instance.coordinates.reduce((acc, _ref) => {
   let {
     axis,
     value
@@ -71,14 +55,11 @@ const variableInstanceSettings = instance => instance === null || instance === v
   acc[axis] = value;
   return acc;
 }, {});
-exports.variableInstanceSettings = variableInstanceSettings;
-const compareVariableSettings = (instance, settings) => instance.coordinates.every(coord => settings[coord.axis] === coord.value);
-exports.compareVariableSettings = compareVariableSettings;
-const variableSettingsCSS = variableSettings => ({
+export const compareVariableSettings = (instance, settings) => instance.coordinates.every(coord => settings[coord.axis] === coord.value);
+export const variableSettingsCSS = variableSettings => ({
   fontVariationSettings: Object.keys(variableSettings).map(axis => `'${axis}' ${variableSettings[axis]}`).join(',')
 });
-exports.variableSettingsCSS = variableSettingsCSS;
-const variableInstanceCSS = variableInstance => ({
+export const variableInstanceCSS = variableInstance => ({
   fontVariationSettings: variableInstance.coordinates.map(_ref2 => {
     let {
       axis,
@@ -87,8 +68,7 @@ const variableInstanceCSS = variableInstance => ({
     return `'${axis}' ${value}`;
   }).join(',')
 });
-exports.variableInstanceCSS = variableInstanceCSS;
-const parseCustomProperties = props => {
+export const parseCustomProperties = props => {
   if (!props) return {};
   return props.reduce((acc, prop) => {
     const [key, val] = prop.split(':');
@@ -96,13 +76,11 @@ const parseCustomProperties = props => {
     return acc;
   }, {});
 };
-exports.parseCustomProperties = parseCustomProperties;
-const inspect = value => {
+export const inspect = value => {
   console.log(value);
   return value;
 };
-exports.inspect = inspect;
-function getFeatureGlyphs(supportedLanguages) {
+export function getFeatureGlyphs(supportedLanguages) {
   if (supportedLanguages !== null && supportedLanguages !== void 0 && supportedLanguages.includes('en')) return 'Aa';
   if (supportedLanguages !== null && supportedLanguages !== void 0 && supportedLanguages.includes('ar')) return 'ت';
   if (supportedLanguages !== null && supportedLanguages !== void 0 && supportedLanguages.includes('gr')) return 'Αα';

package/dist/vanilla/FontStyle.js

@@ -1,11 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _fontfaceobserver = _interopRequireDefault(require("fontfaceobserver"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+import FontFaceObserver from 'fontfaceobserver';
 const FALLBACK_FAMILY = 'Fallback';
 const setStyle = ($el, _ref) => {
   let {
@@ -38,7 +31,7 @@ class FontStyle {
         fontWeight: 'normal',
         fontStyle: 'normal'
       });
-      const observer = new _fontfaceobserver.default(fontFamily, {
+      const observer = new FontFaceObserver(fontFamily, {
         weight: fontWeight,
         style: fontStyle
       });
@@ -56,5 +49,4 @@ class FontStyle {
     });
   }
 }
-var _default = FontStyle;
-exports.default = _default;
+export default FontStyle;

package/dist/vanilla/TruncatedMarkdown.js

@@ -1,9 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
 function insertAfter(newNode, referenceNode) {
   referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
 }
@@ -19,10 +13,9 @@ const init = $element => {
     expand($element);
   });
 };
-class TruncatedMarkdown {
+export default class TruncatedMarkdown {
   constructor() {
     this.$elements = [...document.querySelectorAll('[data-truncated-rest-text]')];
     this.$elements.forEach(init);
   }
-}
-exports.default = TruncatedMarkdown;
+}

package/dist/vite.d.ts

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