fontdue-js 2.22.1 → 2.22.3

package/dist-cjs/reducer.js

@@ -1,291 +0,0 @@
-"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

@@ -1,148 +0,0 @@
-"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-cjs/relay/loadSerializableQuery.js

@@ -1,57 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = loadSerializableQuery;
-var _environment = require("./environment");
-/**
- * RELAY CACHE KEY NORMALIZATION
- *
- * This type transformation is required to fix a cache key inconsistency issue in Relay.
- *
- * THE PROBLEM:
- * Relay's `getOperationVariables()` function always includes ALL argumentDefinitions
- * from the GraphQL operation, even optional ones, setting them to their defaultValue
- * (typically null). This means when Relay generates cache keys, it creates entries like:
- *
- * Cache Key A: { collectionId: "123", tags: null, excludeTags: null, selectable: true }
- * Cache Key B: { collectionId: "123", selectable: true }  // when optional vars omitted
- *
- * Even though these represent the same logical query, they produce different cache keys
- * because `JSON.stringify(stableCopy(variables))` serializes them differently.
- *
- *  (This is possibly caused by NextJS RSC data serialization and hydration)
- *
- * THE ROOT CAUSE:
- * - GraphQL schema defines: `$tags: [String!], $excludeTags: [String!]` (optional)
- * - TypeScript generates: `tags?: ReadonlyArray<string> | null`
- * - Relay's argumentDefinitions include: `{ name: "tags", defaultValue: null }`
- * - getOperationVariables() always sets: `operationVariables[def.name] = def.defaultValue`
- *
- * THE SOLUTION:
- * RequireAllWithNull<T> transforms optional properties to required properties with
- * explicit null values, forcing callers to be consistent. This ensures server-side
- * preloaded queries and client-side cache lookups use identical variable structures.
- *
- * USAGE:
- * Instead of: { tags, excludeTags } // undefined values
- * Use:        { tags: tags ?? null, excludeTags: excludeTags ?? null } // explicit nulls
- *
- * This eliminates cache misses caused by variable structure inconsistencies between
- * server-side rendering and client-side Relay operations.
- */
-
-// 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, options) {
-  if (!('params' in query)) throw new Error('Params not found in query, is it a fragment instead of a query?');
-  const fetcher = (0, _environment.createNetworkFetch)(options);
-  const response = await fetcher(query.params, variables);
-  return {
-    params: query.params,
-    variables,
-    response
-  };
-}

package/dist-cjs/relay/useSerializablePreloadedQuery.js

@@ -1,52 +0,0 @@
-"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

@@ -1,24 +0,0 @@
-"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

@@ -1,49 +0,0 @@
-"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();