fontdue-js 2.22.0 → 2.22.1

package/dist-cjs/reducer.js

@@ -0,0 +1,291 @@
+"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");
+const unselectLicense = (state, action) => {
+  if (!(action.type === 'PRECART_UNSELECT_LICENSE' || action.type === 'PRECART_TOGGLE_LICENSE')) return state;
+  return {
+    ...state,
+    licenseOptions: state.licenseOptions.filter(option => option.licenseId !== action.licenseId)
+  };
+};
+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;
+  return {
+    ...state,
+    licenseOptions: state.licenseOptions.concat(action.licenseOptionSpec)
+  };
+};
+const toggleLicense = (state, action) => {
+  if (action.type !== 'PRECART_TOGGLE_LICENSE') return state;
+  const {
+    licenseOptions
+  } = state;
+  const existingLicenseOption = licenseOptions.findIndex(option => option.licenseId === action.licenseOptionSpec.licenseId);
+  if (existingLicenseOption >= 0 && !action.checked) {
+    return unselectLicense(state, action);
+  } else if (existingLicenseOption === -1 && action.checked) {
+    return selectLicense(state, action);
+  }
+  return state;
+};
+const selectLicenseOption = (state, action) => {
+  if (action.type !== 'PRECART_SELECT_LICENSE_OPTION') return state;
+  const {
+    licenseId,
+    variableId,
+    optionId
+  } = action;
+  const {
+    licenseOptions
+  } = state;
+  return {
+    ...state,
+    licenseOptions: licenseOptions.map(option => {
+      if (option.licenseId === licenseId) {
+        return {
+          ...option,
+          licenseOptions: {
+            ...option.licenseOptions,
+            [variableId]: optionId
+          }
+        };
+      }
+      return option;
+    })
+  };
+};
+const collectionSkuIdWithDiscount = (state, skuId) => {
+  const differences = (0, _utils.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]) {
+      // When differences are equal, prefer a collection that is not the
+      // SKU being selected — this ensures collection bundles are preferred
+      // over selecting the family itself at the same price
+      if (smallest === skuId && key !== skuId) return key;
+      // Among non-self candidates, prefer the one covering more unique
+      // font styles — this ensures the most comprehensive collection wins
+      if (smallest !== skuId && key !== skuId) {
+        const smallestStyles = new Set(state.collectionStyleSkus[smallest]?.fontStyleSkuIds).size;
+        const keyStyles = new Set(state.collectionStyleSkus[key]?.fontStyleSkuIds).size;
+        if (keyStyles > smallestStyles) return key;
+      }
+    }
+    return smallest;
+  }, null);
+  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 setKeysFalse = (acc, key) => {
+  acc[key] = false;
+  return acc;
+};
+const unselectedMembersSkuIds = (state, action) => {
+  if (action.type !== 'SELECT_SKU_ID') throw new Error('Wrong action ${action.type}');
+  const {
+    skuId,
+    selected
+  } = action;
+  if (!selected) return {}; // only do this in case we are selecting something
+
+  // Recursively collect all descendant SKU IDs so that transitive
+  // selections (e.g., collection bundle → family → bundle) are all
+  // marked as false
+  const result = {};
+  const collectMembers = collSkuId => {
+    const members = state.collectionStyleSkus[collSkuId];
+    if (!members) return;
+    for (const id of members.fontStyleSkuIds) {
+      result[id] = false;
+    }
+    for (const id of members.childrenSkuIds) {
+      result[id] = false;
+      collectMembers(id);
+    }
+  };
+  collectMembers(skuId);
+  return result;
+};
+const selectSkuId = (state, action) => {
+  if (action.type !== 'SELECT_SKU_ID') return state;
+  const {
+    skuId,
+    selected
+  } = action;
+  let actualSkuId = skuId;
+  if (selected) {
+    // check if selecting any collections instead of this sku
+    // would reduce the selection price
+    const [collectionSkuId, _amount] = collectionSkuIdWithDiscount(state, skuId);
+    actualSkuId = collectionSkuId || actualSkuId;
+  } else if (state.selectedSkuIds[skuId] === false) {
+    // we're clicking "deselect" on an item that's not actually selected,
+    // it's a member of a collection which is selected. in this case
+    // we'll find the collection and deselect that collection instead
+    const parentId = selectedCollectionSkuIdContainingSkuId(state, skuId);
+    if (parentId) actualSkuId = parentId;
+  }
+  return {
+    ...state,
+    precartOpen: true,
+    selectedSkuIds: {
+      ...state.selectedSkuIds,
+      [actualSkuId]: selected,
+      ...unselectedMembersSkuIds(state, {
+        ...action,
+        skuId: actualSkuId,
+        selected
+      })
+    }
+  };
+};
+const unselectSkus = state => ({
+  ...state,
+  selectedSkuIds: {}
+});
+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)) {
+    return state;
+  }
+  return {
+    ...state,
+    storeModalRoute: {
+      name: action.route,
+      variables: action.variables
+    },
+    storeModalHistory: state.storeModalHistory.concat(state.storeModalRoute)
+  };
+};
+const storeModalReplace = (state, action) => {
+  if (action.type !== 'STORE_MODAL_REPLACE') return state;
+  return {
+    ...state,
+    storeModalRoute: {
+      name: action.route,
+      variables: action.variables
+    }
+  };
+};
+const storeModalBack = state => {
+  const history = state.storeModalHistory;
+  if (history.length < 1) return state;
+  const previousRoute = history[history.length - 1];
+  return {
+    ...state,
+    storeModalRoute: previousRoute,
+    storeModalHistory: history.slice(0, history.length - 1)
+  };
+};
+const updateOrderVariableSelections = (state, action) => {
+  if (action.type !== 'UPDATE_ORDER_VARIABLE_SELECTIONS') return state;
+  return {
+    ...state,
+    orderVariableSelections: action.selections
+  };
+};
+const reducer = (state, action) => {
+  if (!state) throw 'Reducer called without state';
+  switch (action.type) {
+    case 'POPULATE_PRODUCT_STATE':
+      return (0, _productState.populateProductStateReducer)(state, action);
+    case 'PRECART_TOGGLE_LICENSE':
+      return toggleLicense(state, action);
+    case 'PRECART_UNSELECT_LICENSE':
+      return unselectLicense(state, action);
+    case 'PRECART_SELECT_LICENSE':
+      return selectLicense(state, action);
+    case 'PRECART_SELECT_LICENSE_OPTION':
+      return selectLicenseOption(state, action);
+    case 'SELECT_SKU_ID':
+      return selectSkuId(state, action);
+    case 'UNSELECT_SKUS':
+      return unselectSkus(state);
+    case 'OPEN_PRECART':
+      return {
+        ...state,
+        precartOpen: true
+      };
+    case 'CLOSE_PRECART':
+      return {
+        ...state,
+        precartOpen: false
+      };
+    case 'OPEN_CART':
+      return {
+        ...state,
+        cartOpen: true
+      };
+    case 'CLOSE_CART':
+      return {
+        ...state,
+        cartOpen: false
+      };
+    case 'STORE_MODAL_NAVIGATE':
+      return storeModalNavigate(state, action);
+    case 'STORE_MODAL_REPLACE':
+      return storeModalReplace(state, action);
+    case 'STORE_MODAL_BACK':
+      return storeModalBack(state);
+    case 'UPDATE_ORDER_VARIABLE_SELECTIONS':
+      return updateOrderVariableSelections(state, action);
+    case 'UPDATE_LICENSEE_IS_BILLING_IDENTITY':
+      return {
+        ...state,
+        licenseeIsBillingIdentity: action.value
+      };
+    default:
+      return state;
+  }
+};
+function createDefaultStore(config) {
+  const configValue = (0, _ConfigContext.makeConfig)(config);
+  return (0, _redux.createStore)(reducer, {
+    selectedSkuIds: {},
+    // { [skuId]: Boolean }
+    licenseOptions: [],
+    cartOpen: false,
+    precartOpen: false,
+    collectionStyleSkus: {},
+    skuPrices: {},
+    collectionSkus: {},
+    fetchedCollectionIds: [],
+    storeModalRoute: {
+      name: 'index',
+      variables: {
+        excludeTags: configValue.storeModal.indexExcludeTags
+      }
+    },
+    storeModalHistory: [],
+    orderVariableSelections: [],
+    licenseeIsBillingIdentity: null
+  });
+}
+var _default = reducer;
+exports.default = _default;

package/dist-cjs/relay/environment.js

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEnvironment = createEnvironment;
+exports.createNetworkFetch = createNetworkFetch;
+exports.responseCache = exports.networkFetch = void 0;
+exports.useCurrentEnvironment = useCurrentEnvironment;
+var _relayRuntime = require("relay-runtime");
+var _corsError = require("../corsError");
+var _config = require("../config");
+var _package = _interopRequireDefault(require("../../package.json"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// @ts-ignore - JSON default import (ESM named imports from JSON require
+// import attributes which aren't supported consistently across bundlers).
+
+const version = _package.default.version;
+const IS_SERVER = typeof window === typeof undefined;
+
+// 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 undefined !== 'undefined' ? undefined.env : undefined;
+    if (metaEnv) {
+      const v = metaEnv[name] ?? metaEnv[`PUBLIC_${name}`];
+      if (v != null && v !== '') return v;
+    }
+  } catch {}
+  return 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) {
+  return async function networkFetch(request, variables) {
+    const base = options?.url ?? (0, _config.getConfig)().url ?? FONTDUE_URL;
+    if (IS_SERVER && (base == null || base === '')) {
+      throw new Error('fontdue-js: no Fontdue URL configured for server-side fetch. ' + 'Call configure({ url }) at app startup, set FONTDUE_URL in your environment, ' + 'or pass `url` explicitly to loadSerializableQuery / createEnvironment.');
+    }
+    const url = `${base ?? ''}/graphql`;
+    let resp;
+    try {
+      resp = await fetch(url + `?queryName=${request.name}`, {
+        method: 'POST',
+        credentials: 'include',
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+          'fontdue-stripe-integration': options?.stripeIntegration ?? (0, _config.getConfig)().stripeIntegration ?? STRIPE_INTEGRATION ?? 'dynamic',
+          'fontdue-client-version': version
+        },
+        body: JSON.stringify({
+          query: request.text,
+          variables
+        }),
+        // @ts-ignore
+        next: {
+          tags: ['graphql', `operation:${request.name}`]
+        }
+      });
+    } catch (error) {
+      if ((0, _corsError.handlePossibleCorsError)(error, url)) {
+        return {
+          data: undefined,
+          errors: [{
+            message: 'Cross-origin request blocked'
+          }]
+        };
+      }
+      throw error;
+    }
+    const json = await resp.json();
+
+    // GraphQL returns exceptions (for example, a missing required variable) in the "errors"
+    // property of the response. If any exceptions occurred when processing the request,
+    // throw an error to indicate to the developer what went wrong.
+    if (Array.isArray(json.errors)) {
+      const error = json.errors?.[0];
+      console.error('GraphQL Error:', {
+        message: error.message,
+        code: error.extensions?.code,
+        path: error.path
+      });
+    }
+    return json;
+  };
+}
+const networkFetch = createNetworkFetch();
+exports.networkFetch = networkFetch;
+const responseCache = IS_SERVER ? null : new _relayRuntime.QueryResponseCache({
+  size: 250,
+  ttl: CACHE_TTL
+});
+exports.responseCache = responseCache;
+function createNetwork(options) {
+  async function fetchResponse(params, variables, cacheConfig) {
+    const isQuery = params.operationKind === 'query';
+    // @ts-ignore
+    const cacheKey = params.id ?? params.cacheID;
+    const forceFetch = cacheConfig && cacheConfig.force;
+    if (responseCache != null && isQuery && !forceFetch) {
+      const fromCache = responseCache.get(cacheKey, variables);
+      if (fromCache != null) {
+        return Promise.resolve(fromCache);
+      }
+    }
+    return createNetworkFetch(options)(params, variables);
+  }
+  const network = _relayRuntime.Network.create(fetchResponse);
+  return network;
+}
+function createEnvironment(options) {
+  return new _relayRuntime.Environment({
+    network: createNetwork(options),
+    store: new _relayRuntime.Store(_relayRuntime.RecordSource.create()),
+    isServer: IS_SERVER
+  });
+}
+
+// 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;
+function useCurrentEnvironment(options) {
+  if (IS_SERVER) {
+    return createEnvironment(options);
+  }
+  if (clientEnvironment == null) {
+    clientEnvironment = createEnvironment(options);
+  }
+  return clientEnvironment;
+}

package/{dist-bundle/TypeTester.preload.js → dist-cjs/relay/loadSerializableQuery.js}

@@ -1,10 +1,10 @@
-import React__default from 'react';
-import { c as createNetworkFetch } from './chunks/ComponentsContext-CmkN9J4X.js';
-import { T as TypeTesterStandalonePreloadedQueryRenderer, n as node } from './chunks/TypeTesterStandalone-BMWuv8Ca.js';
-import { F as FontdueProvider } from './chunks/index-C4ak9qTL.js';
-import './index.js';
-import 'react-dom';
+"use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadSerializableQuery;
+var _environment = require("./environment");
 /**
  * RELAY CACHE KEY NORMALIZATION
  *
@@ -47,29 +47,11 @@ import 'react-dom';
 // to avoid the client fetches.
 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 fetcher = createNetworkFetch(options);
+  const fetcher = (0, _environment.createNetworkFetch)(options);
   const response = await fetcher(query.params, variables);
   return {
     params: query.params,
     variables,
     response
   };
-}
-
-async function loadTypeTesterQuery(variables, options) {
-  return loadSerializableQuery(node, {
-    familyName: variables.familyName,
-    styleName: variables.styleName,
-    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.
-function TypeTesterPreloaded(props) {
-  return /*#__PURE__*/React__default.createElement(FontdueProvider, null, /*#__PURE__*/React__default.createElement(TypeTesterStandalonePreloadedQueryRenderer, props));
-}
-
-export { TypeTesterPreloaded, loadTypeTesterQuery };
-//# sourceMappingURL=TypeTester.preload.js.map
+}

package/dist-cjs/relay/useSerializablePreloadedQuery.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useSerializablePreloadedQuery;
+var _react = require("react");
+var _reactRelay = require("react-relay");
+var _relayRuntime = require("relay-runtime");
+var _environment = require("./environment");
+// Convert preloaded query object (with raw GraphQL Response) into
+// Relay's PreloadedQuery.
+
+// 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.
+function useSerializablePreloadedQuery(preloadQuery, fetchPolicy = "store-or-network", query) {
+  const environment = (0, _reactRelay.useRelayEnvironment)();
+  (0, _react.useMemo)(() => {
+    writePreloadedQueryToCache(preloadQuery);
+    if (query != null) {
+      const response = preloadQuery.response;
+      const singular = Array.isArray(response) ? response[0] : response;
+      if (singular?.data != null) {
+        const operation = (0, _relayRuntime.createOperationDescriptor)((0, _relayRuntime.getRequest)(query), preloadQuery.variables);
+        environment.commitPayload(operation, singular.data);
+      }
+    }
+  }, [preloadQuery, environment, query]);
+  return {
+    environment,
+    fetchKey: preloadQuery.params.id ?? preloadQuery.params.cacheID,
+    fetchPolicy,
+    isDisposed: false,
+    name: preloadQuery.params.name,
+    kind: "PreloadedQuery",
+    variables: preloadQuery.variables,
+    dispose: () => {
+      return;
+    }
+  };
+}
+function writePreloadedQueryToCache(preloadedQueryObject) {
+  // @ts-ignore
+  const cacheKey = preloadedQueryObject.params.id ?? preloadedQueryObject.params.cacheID;
+  _environment.responseCache?.set(cacheKey, preloadedQueryObject.variables, preloadedQueryObject.response);
+}

package/dist-cjs/retryImport.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = retryImport;
+/**
+ * Wraps a dynamic import in retry logic.
+ *
+ * Retries the factory up to `retries` times with a delay between attempts.
+ * Re-invoking the factory works on Safari (which doesn't cache module-map
+ * failures) and handles transient network blips on all browsers. Chrome and
+ * Firefox cache failed module fetches in the module map, so retries of the
+ * same specifier may return the cached rejection without a network request;
+ * the delay helps partially mitigate that, but is not a guaranteed fix.
+ *
+ * See: https://github.com/whatwg/html/issues/6768
+ */
+function retryImport(load, retries = 2, delay = 1000) {
+  return load().catch(error => {
+    if (retries === 0) throw error;
+    return new Promise(resolve => setTimeout(resolve, delay)).then(() => retryImport(load, retries - 1, delay));
+  });
+}

package/dist-cjs/scripts/updateUnicodeData.js

@@ -0,0 +1,49 @@
+"use strict";
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+// URL from which to fetch the Unicode data
+const UNICODE_DATA_URL = 'https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt';
+
+// Function to fetch the Unicode data
+function fetchUnicodeData() {
+  return new Promise((resolve, reject) => {
+    https.get(UNICODE_DATA_URL, res => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => resolve(data));
+    }).on('error', err => reject(err));
+  });
+}
+
+// Function to parse the Unicode data and convert it into the desired JSON format
+function parseAndConvertData(data) {
+  const lines = data.split('\n');
+  const result = {};
+  lines.forEach(line => {
+    const parts = line.split(';');
+    if (parts.length > 1) {
+      const code = parseInt(parts[0], 16);
+      const name = parts[1].toLowerCase().replace(/\b\w/g, char => char.toUpperCase());
+      result[code] = name;
+    }
+  });
+  return result;
+}
+
+// Main function to fetch, parse, and write the Unicode data to a JSON file
+async function main() {
+  try {
+    const data = await fetchUnicodeData();
+    const jsonData = parseAndConvertData(data);
+    fs.writeFileSync(path.join(__dirname, '../data/unicodeData.ts'), `const data: { [code: string]: string} = ${JSON.stringify(jsonData)}; export default data;`);
+    console.log('unicode data has been written to unicodeData.ts');
+  } catch (error) {
+    console.error('Error:', error);
+  }
+}
+
+// Run the main function
+main();