fontdue-js 3.6.0 → 3.7.0

package/dist/selection.js

@@ -0,0 +1,494 @@
+/*
+ * The Store Modal's selection.
+ *
+ * What the buyer picks – a style, bundle, family or collection bundle – is kept
+ * as picked (`requestedSkuIds`). The SKUs actually selected (`selectedSkuIds`)
+ * are derived from the picks: the cheapest combination of known SKUs in which
+ * every pick sits inside one SKU granting all of its styles – the pick itself,
+ * or something bigger. A selection's price therefore depends only on what's in
+ * it, never on the order it was picked in, and overlapping bundles – every pair
+ * of weights, each upright with its italic, a few triples – are re-partitioned
+ * as it grows (FD-1238).
+ *
+ * A pick is never split into cheaper parts: a family stays a family (or goes
+ * into a collection bundle or superfamily containing it), because buying the
+ * family isn't the same purchase as buying today's styles one by one. Picked
+ * styles do combine freely, and a combination may grant more than was picked: a
+ * family that costs no more than the styles picked from it is selected in their
+ * place. Among equally cheap combinations the one granting the most styles
+ * wins, then the one with the fewest SKUs – so a variable font comes along with
+ * a collection bundle priced like its static family, and a family beats its two
+ * halves at the same price.
+ */
+
+// Nodes the exact search may visit per part of the catalog before it settles
+// for the best combination found so far. Real catalogs finish far below it; it
+// only bounds pathological ones.
+const SEARCH_BUDGET = 20000;
+const MEMO_LIMIT = 10000;
+const EPSILON = 1e-6;
+
+// A SKU can be priced once both its styles and its price are known.
+const isPriceable = (catalog, skuId) => {
+  var _catalog$skuStyleIds$;
+  return (((_catalog$skuStyleIds$ = catalog.skuStyleIds[skuId]) === null || _catalog$skuStyleIds$ === void 0 ? void 0 : _catalog$skuStyleIds$.length) ?? 0) > 0 && typeof catalog.skuPrices[skuId] === 'number';
+};
+const union = (a, b) => [...new Set([...a, ...b])];
+const selectedSkuIdList = state => Object.keys(state.selectedSkuIds).filter(skuId => state.selectedSkuIds[skuId] === true);
+
+// ---------------------------------------------------------------------------
+// Catalog index
+// ---------------------------------------------------------------------------
+
+// Per catalog, worked out once when product data loads:
+//
+// - the styles each priced SKU grants, and which SKUs grant each style;
+// - its bridges: SKUs that hold otherwise separate parts of the catalog
+//   together, like a superfamily over its families or a collection bundle over
+//   a family and its variable font;
+// - the part each style belongs to once the bridges are set aside.
+//
+// Picks in different parts only interact through bridges, so each part is
+// priced on its own and each bridge is either bought or not. Covers already
+// worked out are kept too: every price on the page asks for the selection plus
+// one SKU, so most of each question has been answered before.
+
+const indexCache = new WeakMap();
+const indexFor = _ref => {
+  let {
+    skuStyleIds,
+    skuPrices
+  } = _ref;
+  const cached = indexCache.get(skuStyleIds);
+  if (cached && cached.catalog.skuPrices === skuPrices) return cached;
+  const catalog = {
+    skuStyleIds,
+    skuPrices
+  };
+  const granted = new Map();
+  const skuIdsByStyle = new Map();
+  // Two SKUs granting the same styles at the same price are interchangeable, so
+  // only the first is offered; picking the other is satisfied by it.
+  const offered = new Set();
+  for (const skuId of Object.keys(skuStyleIds).sort()) {
+    if (!isPriceable(catalog, skuId)) continue;
+    const styleIds = new Set(skuStyleIds[skuId]);
+    granted.set(skuId, styleIds);
+    const identity = `${skuPrices[skuId]}|${[...styleIds].sort().join(',')}`;
+    if (offered.has(identity)) continue;
+    offered.add(identity);
+    for (const styleId of styleIds) {
+      skuIdsByStyle.set(styleId, [...(skuIdsByStyle.get(styleId) ?? []), skuId]);
+    }
+  }
+  const offeredSkuIds = new Set([...skuIdsByStyle.values()].flat());
+  const offeredGranted = new Map([...granted].filter(_ref2 => {
+    let [skuId] = _ref2;
+    return offeredSkuIds.has(skuId);
+  }));
+  const bridges = findBridges(offeredGranted);
+  const nonBridges = [...offeredGranted.keys()].filter(skuId => !bridges.includes(skuId));
+  const index = {
+    catalog,
+    granted,
+    skuIdsByStyle,
+    bridges,
+    partOf: connectedStyles(nonBridges, granted),
+    containers: new Map(),
+    parts: new Map(),
+    covers: new Map()
+  };
+  indexCache.set(skuStyleIds, index);
+  return index;
+};
+
+// Each style's part: styles connected through the given SKUs share a root.
+const connectedStyles = (skuIds, granted) => {
+  const parent = new Map();
+  const find = id => {
+    if (!parent.has(id)) parent.set(id, id);
+    let root = id;
+    while (parent.get(root) !== root) root = parent.get(root);
+    parent.set(id, root);
+    return root;
+  };
+  for (const skuId of skuIds) {
+    const [first, ...rest] = granted.get(skuId);
+    find(first);
+    for (const styleId of rest) parent.set(find(styleId), find(first));
+  }
+  return new Map([...parent.keys()].map(styleId => [styleId, find(styleId)]));
+};
+
+// A SKU is a bridge when the styles it grants fall into more than one part
+// without it. Widest first, set aside as found, until a pass finds none – so a
+// collection bundle is found once the superfamily above it is set aside.
+const findBridges = granted => {
+  const width = skuId => granted.get(skuId).size;
+  const byWidth = (a, b) => width(b) - width(a) || (a < b ? -1 : 1);
+  const bridges = [];
+  let remaining = [...granted.keys()];
+  let found = true;
+  while (found) {
+    found = false;
+    for (const skuId of remaining.filter(id => width(id) >= 2).sort(byWidth)) {
+      const others = remaining.filter(id => id !== skuId);
+      const partOf = connectedStyles(others, granted);
+      const parts = new Set([...granted.get(skuId)].map(styleId => partOf.get(styleId) ?? styleId));
+      if (parts.size > 1) {
+        bridges.push(skuId);
+        remaining = others;
+        found = true;
+      }
+    }
+  }
+  return bridges.sort(byWidth);
+};
+
+// The priced SKUs a pick can sit inside: those granting every style it grants.
+const containersOf = (index, pick) => {
+  const cached = index.containers.get(pick);
+  if (cached) return cached;
+  const styleIds = [...index.granted.get(pick)];
+  const shortest = styleIds.map(styleId => index.skuIdsByStyle.get(styleId)).reduce((a, b) => b.length < a.length ? b : a);
+  const containers = shortest.filter(skuId => {
+    const skuStyles = index.granted.get(skuId);
+    return styleIds.every(styleId => skuStyles.has(styleId));
+  });
+  index.containers.set(pick, containers);
+  return containers;
+};
+
+// The parts a pick's styles belong to.
+const partsOf = (index, pick) => {
+  const cached = index.parts.get(pick);
+  if (cached) return cached;
+  const parts = new Set([...index.granted.get(pick)].map(styleId => index.partOf.get(styleId) ?? styleId));
+  index.parts.set(pick, parts);
+  return parts;
+};
+
+// ---------------------------------------------------------------------------
+// Cheapest combination
+// ---------------------------------------------------------------------------
+
+const EMPTY_COVER = {
+  skuIds: [],
+  cost: 0,
+  granted: new Set()
+};
+const isBetter = (a, b) => {
+  if (Math.abs(a.cost - b.cost) > EPSILON) return a.cost < b.cost;
+  if (a.granted.size !== b.granted.size) return a.granted.size > b.granted.size;
+  if (a.skuIds.length !== b.skuIds.length) return a.skuIds.length < b.skuIds.length;
+  return a.skuIds.join(' ') < b.skuIds.join(' ');
+};
+const combine = covers => ({
+  skuIds: covers.flatMap(cover => cover.skuIds).sort(),
+  cost: covers.reduce((sum, cover) => sum + cover.cost, 0),
+  granted: new Set(covers.flatMap(cover => [...cover.granted]))
+});
+const notNull = value => value !== null;
+
+/**
+ * The cheapest set of SKUs in which each of `picks` sits inside one SKU
+ * granting all of its styles, sorted. Picks whose styles or price aren't known
+ * are left out.
+ *
+ * @example
+ *   cheapestSkuIds(['sku:bold', 'sku:regular', 'sku:light'], catalog)
+ *   // => ['sku:light+regular+bold'] rather than a pair plus a single
+ */
+export const cheapestSkuIds = (picks, catalog) => cheapestCombination(picks, catalog).skuIds;
+const selectionCost = (picks, catalog) => cheapestCombination(picks, catalog).cost;
+const cheapestCombination = (picks, catalog) => {
+  const index = indexFor(catalog);
+  const priceable = [...new Set(picks)].filter(pick => index.granted.has(pick)).sort();
+  return cover(priceable, new Set(), index) ?? EMPTY_COVER;
+};
+
+// The cheapest cover of `picks` (sorted) without the `excluded` bridges, or
+// null when some pick has nowhere to sit without them.
+const cover = (picks, excluded, index) => {
+  if (picks.length === 0) return EMPTY_COVER;
+  const key = `${picks.join(',')}#${[...excluded].sort().join(',')}`;
+  if (index.covers.has(key)) return index.covers.get(key);
+  const result = coverUncached(picks, excluded, index);
+  if (index.covers.size >= MEMO_LIMIT) index.covers.clear();
+  index.covers.set(key, result);
+  return result;
+};
+const coverUncached = (picks, excluded, index) => {
+  const available = new Map(picks.map(pick => [pick, containersOf(index, pick).filter(id => !excluded.has(id))]));
+  if (picks.some(pick => available.get(pick).length === 0)) return null;
+  const parts = [...new Set(picks.flatMap(pick => [...partsOf(index, pick)]))];
+  if (parts.length === 1) return branchAndBound(picks, available, index);
+
+  // Parts are joined by a bridge that can hold picks from more than one of
+  // them, and by a pick that itself spans several.
+  const joining = index.bridges.filter(bridge => !excluded.has(bridge)).map(bridge => ({
+    bridge,
+    reached: new Set(picks.filter(pick => available.get(pick).includes(bridge)).flatMap(pick => [...partsOf(index, pick)]))
+  })).filter(_ref3 => {
+    let {
+      reached
+    } = _ref3;
+    return reached.size > 1;
+  });
+  const groups = joinParts(parts, [...joining.map(_ref4 => {
+    let {
+      reached
+    } = _ref4;
+    return reached;
+  }), ...picks.map(pick => partsOf(index, pick))]);
+  if (groups.length > 1) {
+    const groupOfPart = new Map(groups.flatMap((group, i) => group.map(part => [part, i])));
+    const picksByGroup = groups.map(() => []);
+    for (const pick of picks) {
+      const [part] = partsOf(index, pick);
+      picksByGroup[groupOfPart.get(part)].push(pick);
+    }
+    const covers = picksByGroup.map(group => cover(group, excluded, index));
+    return covers.every(notNull) ? combine(covers) : null;
+  }
+
+  // One group held together by bridges: buy the widest or don't. (Every
+  // container of a pick spanning parts is a bridge, so there is one.)
+  const {
+    bridge
+  } = joining[0];
+  const withoutBridge = new Set([...excluded, bridge]);
+  const rest = cover(picks.filter(pick => !available.get(pick).includes(bridge)), withoutBridge, index);
+  const including = rest && combine([{
+    skuIds: [bridge],
+    cost: index.catalog.skuPrices[bridge],
+    granted: index.granted.get(bridge)
+  }, rest]);
+  const excluding = cover(picks, withoutBridge, index);
+  if (!including || !excluding) return including ?? excluding;
+  return isBetter(including, excluding) ? including : excluding;
+};
+
+// Parts sharing any of the `links`, transitively, as groups of parts.
+const joinParts = (parts, links) => {
+  const parent = new Map(parts.map(part => [part, part]));
+  const find = part => {
+    let root = part;
+    while (parent.get(root) !== root) root = parent.get(root);
+    parent.set(part, root);
+    return root;
+  };
+  for (const link of links) {
+    const [first, ...rest] = link;
+    for (const part of rest) parent.set(find(part), find(first));
+  }
+  const groups = new Map();
+  for (const part of parts) groups.set(find(part), [...(groups.get(find(part)) ?? []), part]);
+  return [...groups.values()];
+};
+const countBits = mask => {
+  let count = 0;
+  for (let word of mask) {
+    word -= word >>> 1 & 0x55555555;
+    word = (word & 0x33333333) + (word >>> 2 & 0x33333333);
+    count += Math.imul(word + (word >>> 4) & 0x0f0f0f0f, 0x01010101) >>> 24;
+  }
+  return count;
+};
+const countShared = (a, b) => countBits(a.map((word, i) => word & b[i]));
+const hasBit = (mask, bit) => (mask[bit >>> 5] & 1 << (bit & 31)) !== 0;
+const setBit = (mask, bit) => {
+  mask[bit >>> 5] |= 1 << (bit & 31);
+};
+
+// Exact minimum-cost cover of the picks in one part, by branch and bound:
+// branch on the unplaced pick with the fewest options, and prune a branch once
+// its cost plus a lower bound on the rest (each unplaced pick at its cheapest
+// per-pick share) can't beat the best cover found. Ties aren't pruned, so the
+// tie-breaks see every cover at the best price.
+const branchAndBound = (picks, available, index) => {
+  const words = Math.ceil(picks.length / 32);
+  const masks = new Map();
+  picks.forEach((pick, bit) => {
+    for (const skuId of available.get(pick)) {
+      if (!masks.has(skuId)) masks.set(skuId, new Uint32Array(words));
+      setBit(masks.get(skuId), bit);
+    }
+  });
+  const options = [...masks].map(_ref5 => {
+    let [skuId, mask] = _ref5;
+    return {
+      skuId,
+      price: index.catalog.skuPrices[skuId],
+      mask,
+      holds: countBits(mask),
+      granted: index.granted.get(skuId)
+    };
+  }).sort((a, b) => a.price / a.holds - b.price / b.holds || b.granted.size - a.granted.size || (a.skuId < b.skuId ? -1 : 1));
+  const optionsByPick = picks.map((_, bit) => options.flatMap((option, i) => hasBit(option.mask, bit) ? [i] : []));
+  const toCover = (chosen, cost) => ({
+    skuIds: chosen.map(i => options[i].skuId).sort(),
+    cost,
+    granted: new Set(chosen.flatMap(i => [...options[i].granted]))
+  });
+  const all = new Uint32Array(words);
+  picks.forEach((_, bit) => setBit(all, bit));
+  let best = toCover(...greedyCover(options, all));
+  let budget = SEARCH_BUDGET;
+  const chosen = [];
+  const search = (unplaced, cost) => {
+    if (budget-- <= 0 || cost > best.cost + EPSILON) return;
+    let branchOn = -1;
+    let lowerBound = 0;
+    for (let bit = 0; bit < picks.length; bit++) {
+      if (!hasBit(unplaced, bit)) continue;
+      const pickOptions = optionsByPick[bit];
+      if (branchOn < 0 || pickOptions.length < optionsByPick[branchOn].length) branchOn = bit;
+      let cheapestShare = Infinity;
+      for (const i of pickOptions) {
+        cheapestShare = Math.min(cheapestShare, options[i].price / countShared(options[i].mask, unplaced));
+      }
+      lowerBound += cheapestShare;
+    }
+    if (branchOn < 0) {
+      const candidate = toCover(chosen, cost);
+      if (isBetter(candidate, best)) best = candidate;
+      return;
+    }
+    if (cost + lowerBound > best.cost + EPSILON) return;
+    for (const i of optionsByPick[branchOn]) {
+      chosen.push(i);
+      search(unplaced.map((word, w) => word & ~options[i].mask[w]), cost + options[i].price);
+      chosen.pop();
+    }
+  };
+  search(all, 0);
+  return best;
+};
+
+// A starting cover to prune against: repeatedly take the option with the lowest
+// price per pick it newly holds.
+const greedyCover = (options, all) => {
+  const unplaced = all.slice();
+  const chosen = [];
+  let cost = 0;
+  while (countBits(unplaced) > 0) {
+    let pick = -1;
+    let pickShare = Infinity;
+    options.forEach((option, i) => {
+      const holds = countShared(option.mask, unplaced);
+      if (holds > 0 && option.price / holds < pickShare - EPSILON) {
+        pick = i;
+        pickShare = option.price / holds;
+      }
+    });
+    chosen.push(pick);
+    cost += options[pick].price;
+    options[pick].mask.forEach((word, w) => unplaced[w] &= ~word);
+  }
+  return [chosen, cost];
+};
+
+// ---------------------------------------------------------------------------
+// Selection state
+// ---------------------------------------------------------------------------
+
+/**
+ * Re-derives `selectedSkuIds` from the picks. A pick whose styles or price
+ * aren't known yet – selected from the host page before its product data
+ * arrived – is bought as it is until they are.
+ */
+export const repriceSelection = state => {
+  const unpriceable = state.requestedSkuIds.filter(skuId => !isPriceable(state, skuId));
+  const skuIds = union(cheapestSkuIds(state.requestedSkuIds, state), unpriceable);
+  const unchanged = selectedSkuIdList(state).length === skuIds.length && skuIds.every(skuId => state.selectedSkuIds[skuId]);
+  return unchanged ? state : {
+    ...state,
+    selectedSkuIds: Object.fromEntries(skuIds.map(skuId => [skuId, true]))
+  };
+};
+
+/**
+ * Adds a pick, or takes out every pick sharing a style with the clicked SKU.
+ *
+ * If what's left is still cheapest bought with a SKU granting the clicked one's
+ * styles anyway – it's part of a bundle that costs no more without it – the
+ * click would change nothing, so the picks inside the selected SKUs granting
+ * them go too, as deselecting a member of a selected bundle always has.
+ */
+export const selectSku = (state, skuId, selected) => {
+  if (selected) {
+    return repriceSelection({
+      ...state,
+      requestedSkuIds: union(state.requestedSkuIds, [skuId])
+    });
+  }
+  const sharesStyleWith = styleIds => id => id === skuId || (state.skuStyleIds[id] ?? []).some(styleId => styleIds.includes(styleId));
+  const styleIds = state.skuStyleIds[skuId] ?? [];
+  const next = repriceSelection({
+    ...state,
+    requestedSkuIds: state.requestedSkuIds.filter(id => !sharesStyleWith(styleIds)(id))
+  });
+  if (styleIds.length === 0 || !isSelected(skuId)(next)) return next;
+  const holding = selectedSkuIdList(state).filter(sharesStyleWith(styleIds));
+  const heldStyleIds = [...styleIds, ...holding.flatMap(id => state.skuStyleIds[id] ?? [])];
+  return repriceSelection({
+    ...state,
+    requestedSkuIds: state.requestedSkuIds.filter(id => !sharesStyleWith(heldStyleIds)(id))
+  });
+};
+
+// ---------------------------------------------------------------------------
+// Reading the selection
+// ---------------------------------------------------------------------------
+
+const grantedCache = new WeakMap();
+const grantedStyleIds = state => {
+  const cached = grantedCache.get(state.selectedSkuIds);
+  if (cached && cached.skuStyleIds === state.skuStyleIds) return cached.styleIds;
+  const styleIds = new Set(selectedSkuIdList(state).flatMap(skuId => state.skuStyleIds[skuId] ?? []));
+  grantedCache.set(state.selectedSkuIds, {
+    skuStyleIds: state.skuStyleIds,
+    styleIds
+  });
+  return styleIds;
+};
+
+/**
+ * Whether a SKU – or a style with no SKU of its own – is in the selection:
+ * selected itself, or every style it grants is granted by what is selected.
+ */
+export const isSelected = skuIdOrStyleId => state => {
+  if (!skuIdOrStyleId) return false;
+  if (state.selectedSkuIds[skuIdOrStyleId] === true) return true;
+  const granted = grantedStyleIds(state);
+  if (granted.has(skuIdOrStyleId)) return true;
+  const styleIds = state.skuStyleIds[skuIdOrStyleId];
+  return !!styleIds && styleIds.length > 0 && styleIds.every(styleId => granted.has(styleId));
+};
+const costCache = new WeakMap();
+
+/**
+ * What picking a SKU would add to the selection's price: the cheapest
+ * combination with it, less the current one. Never more than the SKU's own
+ * price, and less when it completes a cheaper bundle – the Store Modal's
+ * “+$X”. Null when the SKU's styles or price aren't known.
+ */
+export const additionalCost = (state, skuId) => {
+  if (!isPriceable(state, skuId)) return null;
+  let cache = costCache.get(state.requestedSkuIds);
+  if (!cache || cache.skuStyleIds !== state.skuStyleIds || cache.skuPrices !== state.skuPrices) {
+    cache = {
+      skuStyleIds: state.skuStyleIds,
+      skuPrices: state.skuPrices,
+      base: selectionCost(state.requestedSkuIds, state),
+      costs: new Map()
+    };
+    costCache.set(state.requestedSkuIds, cache);
+  }
+  if (!cache.costs.has(skuId)) {
+    const withSku = selectionCost(union(state.requestedSkuIds, [skuId]), state);
+    cache.costs.set(skuId, withSku - cache.base);
+  }
+  return cache.costs.get(skuId);
+};

package/dist/utils.d.ts

@@ -1,17 +1,7 @@
-import { CollectionStyleSkus } from './components/Root/productState.js';
-import type { FontdueState } from './reducer.js';
+export { isSelected } from './selection.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;
-export declare const collContainsSkuId: (coll: CollectionStyleSkus | undefined, skuIdOrStyleId: string) => boolean;
-export declare const collTransitivelyContainsSkuId: (collectionStyleSkus: {
-    [key: string]: CollectionStyleSkus | undefined;
-}, collSkuId: string, skuIdOrStyleId: string) => boolean;
-interface CollectionSkuIdsDifferences {
-    [collectionSkuId: string]: number;
-}
-export declare const isSelected: (skuIdOrStyleId: string | null) => (state: FontdueState) => boolean;
-export declare const collectionSkuIdsDifferences: (state: FontdueState, skuId: string) => CollectionSkuIdsDifferences;
 export type VariableSettings = {
     [axis: string]: number;
 };
@@ -31,4 +21,3 @@ export declare const parseCustomProperties: (props: readonly string[] | null | u
 };
 export declare const inspect: (value: any) => any;
 export declare function getFeatureGlyphs(supportedLanguages: readonly string[] | null): "Aa" | "ت" | "Αα" | "Аа" | null;
-export {};

package/dist/utils.js

@@ -1,3 +1,4 @@
+export { isSelected } from './selection.js';
 export const pluralize = (count, singular, plural) => {
   if (count === 1) return `1 ${singular}`;
   if (!plural) return `${count} ${singular}s`;
@@ -11,42 +12,6 @@ export function kebabToCamel(str) {
     return g[1].toUpperCase();
   });
 }
-
-// where coll is a member of `collectionStyleSkus`;
-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)
-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));
-};
-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
-  const parentCollectionSkuIds = Object.keys(state.collectionStyleSkus).filter(collSkuId => collContainsSkuId(state.collectionStyleSkus[collSkuId], skuIdOrStyleId));
-  // Recursively check ancestors — handles transitive selection
-  // (e.g., collection bundle → family → bundle)
-  return parentCollectionSkuIds.some(parentSkuId => isSelected(parentSkuId)(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.
-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));
-  const sumOfSelectedSkuIdsInColl = selectedSkuIdsInColl.map(selectedSkuId => state.skuPrices[selectedSkuId] ?? 0).reduce((acc, price) => acc + price, 0);
-  acc[collectionSkuId] = (state.skuPrices[collectionSkuId] ?? 0) - sumOfSelectedSkuIdsInColl;
-  return acc;
-}, {});
 export const variableInstanceSettings = instance => instance === null || instance === void 0 ? void 0 : instance.coordinates.reduce((acc, _ref) => {
   let {
     axis,

package/dist/version.js

@@ -8,4 +8,4 @@
 // (Fontage.ClientVersions) to spot sites that need to upgrade before a
 // feature that depends on a newer client can work for them.
 export const CLIENT_VERSION_HEADER = 'fontdue-client-version';
-export const version = "3.6.0";
+export const version = "3.7.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fontdue-js",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "type": "module",
   "scripts": {
     "build": "npm run relay && run-p build-js build-css build-ts",