@tabcommerceio/buy-together-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,877 @@
+// src/uuid.ts
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var NIL_UUID = "00000000-0000-0000-0000-000000000000";
+function isUUID(value) {
+  return UUID_PATTERN.test(value);
+}
+function isCanonicalUUID(value) {
+  return typeof value === "string" && value !== NIL_UUID && value === value.toLowerCase() && isUUID(value);
+}
+function createUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (character) => {
+    const random = Math.random() * 16 | 0;
+    const nibble = character === "x" ? random : random & 3 | 8;
+    return nibble.toString(16);
+  });
+}
+
+// src/commerce.ts
+var VARIANT_GID = /^gid:\/\/shopify\/ProductVariant\/([1-9]\d*)$/;
+var PRODUCT_GID = /^gid:\/\/shopify\/Product\/([1-9]\d*)$/;
+function routeURL(routeRoot, path) {
+  let root = typeof routeRoot === "string" && routeRoot ? routeRoot : "/";
+  if (!root.endsWith("/")) root += "/";
+  return `${root}${path}`;
+}
+function componentsAreExact(components) {
+  if (components.length < 2 || components.length > 4) return false;
+  const componentIDs = /* @__PURE__ */ new Set();
+  const products = /* @__PURE__ */ new Set();
+  const variants = /* @__PURE__ */ new Set();
+  for (const component of components) {
+    if (!component || !isCanonicalUUID(component.component_id) || !PRODUCT_GID.test(component.product_id) || !VARIANT_GID.test(component.variant_id)) {
+      return false;
+    }
+    if (componentIDs.has(component.component_id) || products.has(component.product_id) || variants.has(component.variant_id)) return false;
+    componentIDs.add(component.component_id);
+    products.add(component.product_id);
+    variants.add(component.variant_id);
+  }
+  return true;
+}
+function requiredLines(offer, instanceID, requestID) {
+  if (!isCanonicalUUID(offer.offer_id) || !offer.tracking_token.trim() || !isCanonicalUUID(offer.bundle_instance_id) || !isCanonicalUUID(requestID) || !componentsAreExact(offer.components)) {
+    return null;
+  }
+  const lines = [];
+  for (const component of offer.components) {
+    const match = component.variant_id.match(VARIANT_GID);
+    if (!match) return null;
+    lines.push({
+      component,
+      variantNumericID: match[1],
+      properties: {
+        _tab_bundle_instance_id: instanceID,
+        _tab_bundle_tracking_token: offer.tracking_token,
+        _tab_bundle_offer_id: offer.offer_id,
+        _tab_bundle_component_id: component.component_id,
+        _tab_bundle_request_id: requestID
+      }
+    });
+  }
+  return lines;
+}
+function cartLinesFrom(body) {
+  if (!body || typeof body !== "object") return [];
+  const items = body.items;
+  return Array.isArray(items) ? items : [];
+}
+function lineMatches(line, wanted) {
+  if (String(line.id ?? "") !== wanted.variantNumericID || Number(line.quantity ?? 0) < 1) return false;
+  const properties = line.properties;
+  if (!properties || typeof properties !== "object") return false;
+  return Object.entries(wanted.properties).every(([key, value]) => properties[key] === value);
+}
+function provesAll(lines, expected) {
+  return expected.every((wanted) => lines.some((line) => lineMatches(line, wanted)));
+}
+function hasExpectedLine(lines, expected) {
+  return expected.some((wanted) => lines.some((line) => lineMatches(line, wanted)));
+}
+function matchingKeys(lines, expected) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    if (typeof line.key !== "string" || !line.key) continue;
+    if (expected.some((wanted) => lineMatches(line, wanted))) keys.add(line.key);
+  }
+  return [...keys];
+}
+async function safeJSON(response) {
+  try {
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function compensate(fetchImpl, routeRoot, keys, provedAbsence, expected) {
+  if (keys.length === 0) {
+    return provedAbsence ? { status: "failed" } : { status: "recoverable_error" };
+  }
+  try {
+    const response = await fetchImpl(routeURL(routeRoot, "cart/update.js"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ updates: Object.fromEntries(keys.map((key) => [key, 0])) }),
+      credentials: "same-origin"
+    });
+    if (!response.ok) return { status: "recoverable_error" };
+    const cartResponse = await fetchImpl(routeURL(routeRoot, "cart.js"), {
+      method: "GET",
+      credentials: "same-origin"
+    });
+    if (!cartResponse.ok) return { status: "recoverable_error" };
+    const body = await safeJSON(cartResponse);
+    const items = body && typeof body === "object" ? body.items : null;
+    if (!Array.isArray(items)) return { status: "recoverable_error" };
+    return hasExpectedLine(items, expected) ? { status: "recoverable_error" } : { status: "compensated" };
+  } catch {
+    return { status: "recoverable_error" };
+  }
+}
+async function addBundleToCart(options) {
+  const quoteExpiry = Date.parse(options.offer.quote_expires_at);
+  if (!Number.isFinite(quoteExpiry) || quoteExpiry <= (options.now ?? Date.now)()) return { status: "failed" };
+  const createId = options.createId ?? createUUID;
+  const instanceID = options.offer.bundle_instance_id;
+  const requestID = createId();
+  const expected = requiredLines(options.offer, instanceID, requestID);
+  if (!expected) return { status: "failed" };
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  let addLines = [];
+  let addProved = false;
+  try {
+    const addResponse = await fetchImpl(routeURL(options.routeRoot, "cart/add.js"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        items: expected.map((wanted) => ({
+          id: Number(wanted.variantNumericID),
+          quantity: 1,
+          properties: wanted.properties
+        }))
+      }),
+      credentials: "same-origin"
+    });
+    if (addResponse.ok) {
+      addLines = cartLinesFrom(await safeJSON(addResponse));
+      addProved = provesAll(addLines, expected);
+    }
+  } catch {
+  }
+  let cartLines = [];
+  let cartProved = false;
+  let cartReadOK = false;
+  try {
+    const cartResponse = await fetchImpl(routeURL(options.routeRoot, "cart.js"), {
+      method: "GET",
+      credentials: "same-origin"
+    });
+    if (cartResponse.ok) {
+      const body = await safeJSON(cartResponse);
+      const items = body && typeof body === "object" ? body.items : null;
+      if (Array.isArray(items)) {
+        cartReadOK = true;
+        cartLines = items;
+        cartProved = provesAll(cartLines, expected);
+      }
+    }
+  } catch {
+  }
+  if (addProved && cartProved) {
+    try {
+      options.track({
+        event_type: "add_to_cart",
+        offer_id: options.offer.offer_id,
+        request_id: requestID,
+        tracking_token: options.offer.tracking_token
+      });
+    } catch {
+    }
+    try {
+      await options.onAdded?.();
+    } catch {
+    }
+    return { status: "added" };
+  }
+  const keys = cartReadOK ? matchingKeys(cartLines, expected) : matchingKeys(addLines, expected);
+  return compensate(fetchImpl, options.routeRoot, keys, cartReadOK, expected);
+}
+
+// src/events.ts
+var MAX_BUNDLE_EVENTS_BATCH = 100;
+var MAX_PENDING_BUNDLE_EVENTS = 100;
+var RETRY_BACKOFF_BASE_MS = 2e3;
+var RETRY_BACKOFF_MAX_MS = 6e4;
+var MAX_BUNDLE_EVENTS_BATCH_BYTES = 56 * 1024;
+function normalizeProxyBase(proxyBase) {
+  return proxyBase.replace(/\/+$/, "");
+}
+function utf8Length(value) {
+  if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(value).length;
+  return value.length;
+}
+var BATCH_ENVELOPE_BYTES = utf8Length('{"items":[]}');
+function nextBatch(pending, remaining) {
+  const batch = [];
+  let bytes = BATCH_ENVELOPE_BYTES;
+  const max = Math.min(MAX_BUNDLE_EVENTS_BATCH, remaining, pending.length);
+  for (let index = 0; index < max; index += 1) {
+    const eventBytes = utf8Length(JSON.stringify(pending[index])) + (batch.length > 0 ? 1 : 0);
+    if (batch.length > 0 && bytes + eventBytes > MAX_BUNDLE_EVENTS_BATCH_BYTES) break;
+    batch.push(pending[index]);
+    bytes += eventBytes;
+  }
+  return { batch, overBudget: bytes > MAX_BUNDLE_EVENTS_BATCH_BYTES };
+}
+function createBundleEventQueue(options = {}) {
+  const pending = [];
+  const createEventId = options.createEventId ?? createUUID;
+  const now = options.now ?? (() => Date.now());
+  let backoffMs = 0;
+  let nextAttemptAt = 0;
+  function enqueue(event) {
+    if (pending.length >= MAX_PENDING_BUNDLE_EVENTS) pending.shift();
+    pending.push(event);
+    options.onEnqueued?.(pending.length);
+  }
+  function track(input) {
+    const event = {
+      event_id: input.event_id ?? createEventId(),
+      occurred_at: input.occurred_at ?? new Date(now()).toISOString(),
+      event_type: input.event_type,
+      tracking_token: input.tracking_token,
+      offer_id: input.offer_id,
+      request_id: input.request_id,
+      attrs: input.attrs
+    };
+    enqueue(event);
+    return event;
+  }
+  function scheduleRetry() {
+    backoffMs = Math.min(
+      backoffMs > 0 ? backoffMs * 2 : RETRY_BACKOFF_BASE_MS,
+      RETRY_BACKOFF_MAX_MS
+    );
+    nextAttemptAt = now() + backoffMs;
+  }
+  async function flush() {
+    if (pending.length === 0) return;
+    if (!options.proxyBase) throw new Error("proxyBase is required to flush Bundle events");
+    if (now() < nextAttemptAt) return;
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    const countAtStart = pending.length;
+    let processed = 0;
+    while (processed < countAtStart) {
+      const { batch, overBudget } = nextBatch(pending, countAtStart - processed);
+      if (batch.length === 0) return;
+      let response;
+      try {
+        response = await fetchImpl(`${normalizeProxyBase(options.proxyBase)}/bundle-offers/events`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ items: batch }),
+          // An over-budget single event would be rejected synchronously with
+          // keepalive; deliver it as an ordinary request instead.
+          keepalive: !overBudget,
+          credentials: "same-origin"
+        });
+      } catch {
+        scheduleRetry();
+        return;
+      }
+      if (!response.ok && (response.status === 429 || response.status >= 500)) {
+        scheduleRetry();
+        return;
+      }
+      backoffMs = 0;
+      nextAttemptAt = 0;
+      const delivered = new Set(batch.map((event) => event.event_id));
+      for (let index = pending.length - 1; index >= 0; index -= 1) {
+        if (delivered.has(pending[index].event_id)) pending.splice(index, 1);
+      }
+      processed += batch.length;
+    }
+  }
+  return { track, enqueue, flush, pending: () => pending.slice() };
+}
+
+// src/flush.ts
+function createBundleFlushController(options) {
+  const intervalMs = options.intervalMs ?? 2e3;
+  const threshold = options.threshold ?? 10;
+  const setIntervalImpl = options.setIntervalImpl ?? setInterval;
+  const clearIntervalImpl = options.clearIntervalImpl ?? clearInterval;
+  let timer = null;
+  let flushing = false;
+  let flushAgain = false;
+  async function flushNow() {
+    if (flushing) {
+      flushAgain = true;
+      return;
+    }
+    flushing = true;
+    try {
+      do {
+        flushAgain = false;
+        await options.flush();
+      } while (flushAgain);
+    } finally {
+      flushing = false;
+    }
+  }
+  const onLifecycle = () => {
+    void flushNow().catch(() => {
+    });
+  };
+  function start() {
+    if (timer !== null) return;
+    timer = setIntervalImpl(onLifecycle, intervalMs);
+    options.documentRef?.addEventListener("visibilitychange", onLifecycle);
+    options.windowRef?.addEventListener("pagehide", onLifecycle);
+  }
+  function stop() {
+    if (timer !== null) {
+      clearIntervalImpl(timer);
+      timer = null;
+    }
+    options.documentRef?.removeEventListener("visibilitychange", onLifecycle);
+    options.windowRef?.removeEventListener("pagehide", onLifecycle);
+  }
+  return {
+    start,
+    stop,
+    flushNow,
+    notifyEnqueued(count) {
+      if (count >= threshold) void flushNow().catch(() => {
+      });
+    }
+  };
+}
+
+// src/observer.ts
+var BUNDLE_IMPRESSION_MIN_RATIO = 0.5;
+var BUNDLE_IMPRESSION_MIN_DURATION_MS = 500;
+var RATIO_EPSILON = 1e-4;
+function createBundleImpressionObserver(options) {
+  const now = options.now ?? (() => Date.now());
+  const setTimeoutImpl = options.setTimeoutImpl ?? setTimeout;
+  const clearTimeoutImpl = options.clearTimeoutImpl ?? clearTimeout;
+  const Observer = options.IntersectionObserverImpl ?? globalThis.IntersectionObserver;
+  const seen = /* @__PURE__ */ new Set();
+  const targets = /* @__PURE__ */ new WeakMap();
+  const pending = /* @__PURE__ */ new Map();
+  function hidden() {
+    return options.documentRef?.hidden === true;
+  }
+  function emitAfterThreshold(item) {
+    if (item.timer !== null || hidden()) return;
+    item.startedAt = now();
+    item.timer = setTimeoutImpl(() => {
+      const current = pending.get(item.target.tracking_token);
+      if (!current || seen.has(current.target.tracking_token) || hidden()) return;
+      current.timer = null;
+      seen.add(current.target.tracking_token);
+      pending.delete(current.target.tracking_token);
+      options.onImpression({
+        tracking_token: current.target.tracking_token,
+        offer_id: current.target.offer_id,
+        request_id: current.target.request_id,
+        attrs: {
+          visibility: { ratio: current.ratio, duration_ms: now() - current.startedAt }
+        }
+      });
+    }, BUNDLE_IMPRESSION_MIN_DURATION_MS);
+  }
+  const onVisibilityChange = () => {
+    for (const item of pending.values()) {
+      if (hidden()) {
+        if (item.timer !== null) clearTimeoutImpl(item.timer);
+        item.timer = null;
+      } else {
+        emitAfterThreshold(item);
+      }
+    }
+  };
+  if (!Observer) {
+    return {
+      observe: (_items) => {
+      },
+      disconnect: () => {
+      },
+      seenTokens: () => new Set(seen)
+    };
+  }
+  const observer = new Observer(
+    (entries) => {
+      for (const entry of entries) {
+        const target = targets.get(entry.target);
+        if (!target || seen.has(target.tracking_token)) continue;
+        const qualifies = entry.isIntersecting && entry.intersectionRatio >= BUNDLE_IMPRESSION_MIN_RATIO - RATIO_EPSILON;
+        const current = pending.get(target.tracking_token);
+        if (!qualifies) {
+          if (current?.timer !== null && current?.timer !== void 0) clearTimeoutImpl(current.timer);
+          pending.delete(target.tracking_token);
+          continue;
+        }
+        if (current) {
+          current.ratio = entry.intersectionRatio;
+          current.target = target;
+          emitAfterThreshold(current);
+          continue;
+        }
+        const item = {
+          target,
+          ratio: entry.intersectionRatio,
+          startedAt: now(),
+          timer: null
+        };
+        pending.set(target.tracking_token, item);
+        emitAfterThreshold(item);
+      }
+    },
+    { threshold: [0, BUNDLE_IMPRESSION_MIN_RATIO, 1] }
+  );
+  options.documentRef?.addEventListener("visibilitychange", onVisibilityChange);
+  return {
+    observe(items) {
+      for (const item of items) {
+        targets.set(item.element, item);
+        observer.observe(item.element);
+      }
+    },
+    disconnect() {
+      for (const item of pending.values()) {
+        if (item.timer !== null) clearTimeoutImpl(item.timer);
+      }
+      pending.clear();
+      observer.disconnect();
+      options.documentRef?.removeEventListener("visibilitychange", onVisibilityChange);
+    },
+    seenTokens: () => new Set(seen)
+  };
+}
+
+// src/resolve.ts
+var SLOT_KEY = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var PRODUCT_GID2 = /^gid:\/\/shopify\/Product\/[1-9]\d{0,19}$/;
+var VARIANT_GID2 = /^gid:\/\/shopify\/ProductVariant\/[1-9]\d{0,19}$/;
+var MONEY_AMOUNT = /^(?:0|[1-9]\d*)(?:\.\d+)?$/;
+var DEFAULT_RESOLVE_LIMIT = 10;
+var MAX_POSITION = 2147483647;
+function normalizeProxyBase2(proxyBase) {
+  return proxyBase.replace(/\/+$/, "");
+}
+function validContext(request) {
+  return Boolean(request.context?.country?.trim() && request.cart?.currency?.trim());
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isNonBlankString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isPosition(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= MAX_POSITION;
+}
+function hasPositiveMoney(value, currency) {
+  if (!isRecord(value)) return false;
+  const amount = value.amount;
+  return typeof amount === "string" && amount === amount.trim() && MONEY_AMOUNT.test(amount) && /[1-9]/.test(amount) && value.currency === currency;
+}
+function hasExactComponents(value, currency) {
+  if (!Array.isArray(value) || value.length < 2 || value.length > 4) return false;
+  const componentIDs = /* @__PURE__ */ new Set();
+  const products = /* @__PURE__ */ new Set();
+  const variants = /* @__PURE__ */ new Set();
+  let previousProductID = null;
+  return value.every((candidate) => {
+    if (!isRecord(candidate)) return false;
+    const componentID = candidate.component_id;
+    const productID = candidate.product_id;
+    const variantID = candidate.variant_id;
+    const options = candidate.options;
+    const eligibleVariants = candidate.variants;
+    if (!isCanonicalUUID(componentID) || typeof productID !== "string" || !PRODUCT_GID2.test(productID) || typeof variantID !== "string" || !VARIANT_GID2.test(variantID) || !isNonBlankString(candidate.product_title) || !Array.isArray(options) || !options.every(isNonBlankString) || !Array.isArray(eligibleVariants) || eligibleVariants.length < 1 || !eligibleVariants.every((variant) => hasEligibleVariant(variant, currency)) || !eligibleVariants.some((variant) => isRecord(variant) && variant.variant_id === variantID && variant.available === true) || "image_url" in candidate && !isNonBlankString(candidate.image_url) || componentIDs.has(componentID) || products.has(productID) || variants.has(variantID) || previousProductID !== null && previousProductID >= productID) {
+      return false;
+    }
+    componentIDs.add(componentID);
+    products.add(productID);
+    variants.add(variantID);
+    previousProductID = productID;
+    return true;
+  });
+}
+function hasEligibleVariant(value, currency) {
+  if (!isRecord(value)) return false;
+  return typeof value.variant_id === "string" && VARIANT_GID2.test(value.variant_id) && isNonBlankString(value.title) && Array.isArray(value.option_values) && value.option_values.every(isNonBlankString) && value.available === true && hasPositiveMoney(value.price, currency);
+}
+function hasFutureQuoteExpiry(value) {
+  if (typeof value !== "string") return false;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) && timestamp > Date.now();
+}
+function hasValidOfferSurface(offer, request, expectedSurface, expectedSlot) {
+  if (expectedSurface) {
+    return offer.surface === expectedSurface && (expectedSurface === "api_slot" ? offer.slot_key === expectedSlot : offer.slot_key === void 0);
+  }
+  if (typeof request.slot_key === "string") {
+    return offer.surface === "api_slot" && offer.slot_key === request.slot_key && request.slot_key.length <= 64 && SLOT_KEY.test(request.slot_key);
+  }
+  return offer.surface === "api_offer_ids" && offer.slot_key === void 0;
+}
+function hasContractBundleOffer(value, requestID, request, expectedSurface, expectedSlot) {
+  if (!isRecord(value)) return false;
+  const trackingToken = value.tracking_token;
+  return isCanonicalUUID(value.campaign_id) && isCanonicalUUID(value.offer_id) && isCanonicalUUID(value.publish_version_id) && isPositiveInteger(value.campaign_version) && isPositiveInteger(value.revision) && isPosition(value.position) && isNonBlankString(value.name) && isNonBlankString(value.message) && hasExactComponents(value.components, request.cart.currency) && hasPositiveMoney(value.regular_total, request.cart.currency) && hasPositiveMoney(value.offer_total, request.cart.currency) && hasPositiveMoney(value.savings, request.cart.currency) && typeof trackingToken === "string" && trackingToken === trackingToken.trim() && trackingToken.length > 0 && isCanonicalUUID(value.bundle_instance_id) && hasFutureQuoteExpiry(value.quote_expires_at) && value.request_id === requestID && hasValidOfferSurface(value, request, expectedSurface, expectedSlot);
+}
+function isValidQuoteRequest(request) {
+  if (!validContext(request) || !isNonBlankString(request.tracking_token) || request.tracking_token !== request.tracking_token.trim() || request.tracking_token.length > 1024 || !Array.isArray(request.selections) || request.selections.length < 2 || request.selections.length > 4) return false;
+  const components = /* @__PURE__ */ new Set();
+  const products = /* @__PURE__ */ new Set();
+  const variants = /* @__PURE__ */ new Set();
+  return request.selections.every((selected) => {
+    if (!isCanonicalUUID(selected.component_id) || !PRODUCT_GID2.test(selected.product_id) || !VARIANT_GID2.test(selected.variant_id) || components.has(selected.component_id) || products.has(selected.product_id) || variants.has(selected.variant_id)) return false;
+    components.add(selected.component_id);
+    products.add(selected.product_id);
+    variants.add(selected.variant_id);
+    return true;
+  });
+}
+function hasContractQuoteResponse(value, request) {
+  if (!isRecord(value) || !isCanonicalUUID(value.request_id) || typeof value.eligible !== "boolean") return false;
+  if (!value.eligible) return value.offer === void 0 && ["stale_offer", "invalid_selection", "temporarily_unavailable"].includes(String(value.reason));
+  if (value.reason !== void 0 || !isRecord(value.offer)) return false;
+  const offer = value.offer;
+  if (offer.request_id !== value.request_id || !["pdp", "api_slot", "api_offer_ids"].includes(String(offer.surface))) return false;
+  const selected = new Map(request.selections.map((item) => [item.component_id, item]));
+  if (!Array.isArray(offer.components) || offer.components.length !== request.selections.length || offer.components.some((item) => !isRecord(item) || selected.get(String(item.component_id))?.product_id !== item.product_id || selected.get(String(item.component_id))?.variant_id !== item.variant_id)) return false;
+  const surface = offer.surface;
+  const slot = surface === "api_slot" && typeof offer.slot_key === "string" ? offer.slot_key : void 0;
+  const resolveRequest = surface === "api_slot" ? { slot_key: slot ?? "", context: request.context, cart: request.cart } : { offer_ids: [String(offer.offer_id)], context: request.context, cart: request.cart };
+  return hasContractBundleOffer(offer, value.request_id, resolveRequest, surface, slot);
+}
+function hasContractResolveResponse(value, request) {
+  if (!isRecord(value) || !isCanonicalUUID(value.request_id) || !Array.isArray(value.offers)) return false;
+  const requestID = value.request_id;
+  const limit = request.limit ?? DEFAULT_RESOLVE_LIMIT;
+  if (value.offers.length > limit) return false;
+  const offerIDs = /* @__PURE__ */ new Set();
+  const instanceIDs = /* @__PURE__ */ new Set();
+  let previousRequestedIndex = -1;
+  return value.offers.every((offer) => {
+    if (!hasContractBundleOffer(offer, requestID, request)) return false;
+    const identity = offer;
+    const offerID = identity.offer_id;
+    const instanceID = identity.bundle_instance_id;
+    if (offerIDs.has(offerID) || instanceIDs.has(instanceID)) return false;
+    offerIDs.add(offerID);
+    instanceIDs.add(instanceID);
+    if (!Array.isArray(request.offer_ids)) return true;
+    const requestedIndex = request.offer_ids.indexOf(offerID);
+    if (requestedIndex < 0 || requestedIndex <= previousRequestedIndex) return false;
+    previousRequestedIndex = requestedIndex;
+    return true;
+  });
+}
+function isValidBundleResolveRequest(request) {
+  if (!validContext(request)) return false;
+  if (request.limit !== void 0 && (!Number.isInteger(request.limit) || request.limit < 1 || request.limit > 20)) {
+    return false;
+  }
+  const hasSlot = typeof request.slot_key === "string";
+  const hasOffers = Array.isArray(request.offer_ids);
+  if (hasSlot === hasOffers) return false;
+  if (hasSlot) return request.slot_key.length <= 64 && SLOT_KEY.test(request.slot_key);
+  if (!hasOffers || request.offer_ids.length < 1 || request.offer_ids.length > 20) return false;
+  const ids = /* @__PURE__ */ new Set();
+  return request.offer_ids.every((id) => {
+    if (!isCanonicalUUID(id) || ids.has(id)) return false;
+    ids.add(id);
+    return true;
+  });
+}
+function isValidPDPRequest(request) {
+  return Boolean(
+    validContext(request) && PRODUCT_GID2.test(request.source_product_id) && VARIANT_GID2.test(request.source_variant_id) && isCanonicalUUID(request.bundle_instance_id)
+  );
+}
+async function readData(response) {
+  try {
+    const body = await response.json();
+    return body?.data;
+  } catch {
+    return null;
+  }
+}
+async function resolveBundleOffers(request, options) {
+  if (!isValidBundleResolveRequest(request)) return null;
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  try {
+    const response = await fetchImpl(`${normalizeProxyBase2(options.proxyBase)}/bundle-offers/resolve`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(request),
+      signal: options.signal,
+      credentials: "same-origin"
+    });
+    if (!response.ok) return null;
+    const data = await readData(response);
+    if (!hasContractResolveResponse(data, request)) return null;
+    return { request_id: data.request_id, offers: data.offers };
+  } catch {
+    return null;
+  }
+}
+async function resolveBundlePDP(request, options) {
+  if (!isValidPDPRequest(request)) return null;
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  try {
+    const response = await fetchImpl(
+      `${normalizeProxyBase2(options.proxyBase)}/bundle-offers/pdp/rendered`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(request),
+        signal: options.signal,
+        credentials: "same-origin"
+      }
+    );
+    if (!response.ok) return null;
+    const data = await readData(response);
+    if (!data || typeof data !== "object") return null;
+    const value = data;
+    if (typeof value.html !== "string" || !isCanonicalUUID(value.request_id)) return null;
+    return { html: value.html, request_id: value.request_id };
+  } catch {
+    return null;
+  }
+}
+async function quoteBundleOffer(request, options) {
+  if (!isValidQuoteRequest(request)) return null;
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  try {
+    const response = await fetchImpl(`${normalizeProxyBase2(options.proxyBase)}/bundle-offers/quote`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(request),
+      signal: options.signal,
+      credentials: "same-origin"
+    });
+    if (!response.ok) return null;
+    const data = await readData(response);
+    return hasContractQuoteResponse(data, request) ? data : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/client.ts
+function textAttribute(element, name) {
+  return String(element.getAttribute(name) || "").trim();
+}
+function collectBundleObserveTargets(root) {
+  return Array.from(root.querySelectorAll("[data-tab-buy-together-offer]")).map((element) => ({
+    element,
+    tracking_token: textAttribute(element, "data-tab-buy-together-tracking-token"),
+    offer_id: textAttribute(element, "data-tab-buy-together-offer-id"),
+    request_id: textAttribute(element, "data-tab-buy-together-request-id")
+  }));
+}
+function isTrackable(target) {
+  return Boolean(target.tracking_token && target.offer_id && target.request_id);
+}
+function init(options) {
+  const documentRef = options.documentRef ?? (typeof document !== "undefined" ? document : void 0);
+  const windowRef = options.windowRef ?? (typeof window !== "undefined" ? window : void 0);
+  const observers = /* @__PURE__ */ new Set();
+  const mountedPDP = /* @__PURE__ */ new WeakMap();
+  const activePDP = /* @__PURE__ */ new Set();
+  let notifyEnqueued = () => {
+  };
+  const queue = createBundleEventQueue({
+    proxyBase: options.proxyBase,
+    fetchImpl: options.fetchImpl,
+    createEventId: options.createEventId,
+    now: options.now,
+    onEnqueued: (count) => notifyEnqueued(count)
+  });
+  const flushController = createBundleFlushController({
+    flush: () => queue.flush(),
+    intervalMs: options.flushIntervalMs,
+    threshold: options.flushThreshold,
+    documentRef,
+    windowRef
+  });
+  notifyEnqueued = (count) => flushController.notifyEnqueued(count);
+  flushController.start();
+  function track(input) {
+    queue.track(input);
+  }
+  function resolve(request, signal) {
+    return resolveBundleOffers(request, {
+      proxyBase: options.proxyBase,
+      fetchImpl: options.fetchImpl,
+      signal
+    });
+  }
+  function resolvePDP(request, signal) {
+    return resolveBundlePDP(request, {
+      proxyBase: options.proxyBase,
+      fetchImpl: options.fetchImpl,
+      signal
+    });
+  }
+  function quote(request, signal) {
+    return quoteBundleOffer(request, { proxyBase: options.proxyBase, fetchImpl: options.fetchImpl, signal });
+  }
+  async function mountPDP(mountOptions) {
+    const prior = mountedPDP.get(mountOptions.root);
+    prior?.controller.abort();
+    prior?.unmount();
+    if (prior) activePDP.delete(prior);
+    const controller = new AbortController();
+    const mounted = { controller, unmount: () => {
+    } };
+    mountedPDP.set(mountOptions.root, mounted);
+    activePDP.add(mounted);
+    mountOptions.root.innerHTML = "";
+    const abortExternal = () => controller.abort();
+    mountOptions.signal?.addEventListener("abort", abortExternal, { once: true });
+    if (mountOptions.signal?.aborted) controller.abort();
+    const rendered = await resolvePDP(mountOptions.request, controller.signal);
+    mountOptions.signal?.removeEventListener("abort", abortExternal);
+    if (mountedPDP.get(mountOptions.root) !== mounted || controller.signal.aborted) {
+      activePDP.delete(mounted);
+      return () => {
+      };
+    }
+    if (!rendered || !rendered.html.trim()) {
+      return () => {
+      };
+    }
+    mountOptions.root.innerHTML = rendered.html;
+    const targets = collectBundleObserveTargets(mountOptions.root).filter(isTrackable);
+    if (targets.length === 0) return () => {
+    };
+    const observer = createBundleImpressionObserver({
+      IntersectionObserverImpl: options.IntersectionObserverImpl,
+      documentRef,
+      now: options.now,
+      onImpression: (payload) => {
+        track({
+          event_type: "impression",
+          tracking_token: payload.tracking_token,
+          offer_id: payload.offer_id,
+          request_id: payload.request_id,
+          attrs: payload.attrs
+        });
+      }
+    });
+    observer.observe(targets);
+    observers.add(observer);
+    mounted.unmount = () => {
+      observer.disconnect();
+      observers.delete(observer);
+    };
+    return () => {
+      if (mountedPDP.get(mountOptions.root) === mounted) {
+        mounted.unmount();
+        mountedPDP.delete(mountOptions.root);
+        activePDP.delete(mounted);
+      }
+    };
+  }
+  function addAll(offer, addOptions = {}) {
+    return addBundleToCart({
+      ...addOptions,
+      offer,
+      fetchImpl: options.fetchImpl,
+      track
+    });
+  }
+  function destroy() {
+    for (const mounted of activePDP) {
+      mounted.controller.abort();
+      mounted.unmount();
+    }
+    activePDP.clear();
+    for (const observer of observers) observer.disconnect();
+    observers.clear();
+    flushController.stop();
+    void flushController.flushNow().catch(() => {
+    });
+  }
+  return {
+    resolve,
+    resolvePDP,
+    quote,
+    mountPDP,
+    addAll,
+    track,
+    flush: () => flushController.flushNow().catch(() => {
+    }),
+    destroy
+  };
+}
+
+// src/pdp-sequencer.ts
+function createPDPRequestSequencer(options) {
+  let generation = 0;
+  let controller = null;
+  async function run(request) {
+    generation += 1;
+    const currentGeneration = generation;
+    controller?.abort();
+    controller = new AbortController();
+    options.onClear();
+    try {
+      const result = await options.resolve(request, controller.signal);
+      if (currentGeneration !== generation || controller.signal.aborted || result === null) return null;
+      options.onResult(result);
+      return result;
+    } catch {
+      return null;
+    }
+  }
+  function cancel() {
+    generation += 1;
+    controller?.abort();
+    controller = null;
+  }
+  return { run, cancel };
+}
+
+// src/quote-fence.ts
+function createQuoteRequestFence() {
+  let revision = 0;
+  let controller = null;
+  return {
+    begin() {
+      controller?.abort();
+      controller = new AbortController();
+      return { revision: ++revision, signal: controller.signal };
+    },
+    isCurrent(attempt) {
+      return attempt.revision === revision && !attempt.signal.aborted;
+    },
+    cancel() {
+      revision += 1;
+      controller?.abort();
+      controller = null;
+    }
+  };
+}
+export {
+  BUNDLE_IMPRESSION_MIN_DURATION_MS,
+  BUNDLE_IMPRESSION_MIN_RATIO,
+  MAX_BUNDLE_EVENTS_BATCH,
+  addBundleToCart,
+  collectBundleObserveTargets,
+  createBundleEventQueue,
+  createBundleFlushController,
+  createBundleImpressionObserver,
+  createPDPRequestSequencer,
+  createQuoteRequestFence,
+  init,
+  isValidBundleResolveRequest,
+  quoteBundleOffer,
+  resolveBundleOffers,
+  resolveBundlePDP
+};
+//# sourceMappingURL=index.js.map