@appfunnel-dev/sdk 2.0.0-canary.1 → 2.0.0-canary.11

package/dist/chunk-SXENKZ4U.js

@@ -0,0 +1,486 @@
+// src/i18n/locale.ts
+var RTL_LANGS = /* @__PURE__ */ new Set(["ar", "he", "fa", "ur", "ps", "sd", "dv", "yi"]);
+function isRtl(locale) {
+  return RTL_LANGS.has(locale.split("-")[0]);
+}
+var base = (l) => l?.split("-")[0];
+function resolveLocale(config, detected, override) {
+  const supported = config?.supported ?? (config?.default ? [config.default] : ["en"]);
+  const def = config?.default ?? supported[0] ?? "en";
+  const pick = (l) => {
+    if (!l) return void 0;
+    if (supported.includes(l)) return l;
+    return supported.find((s) => base(s) === base(l));
+  };
+  return pick(override) ?? pick(detected) ?? def;
+}
+
+// src/commerce/money.ts
+var PERIOD_DAYS = {
+  day: 1,
+  week: 7,
+  month: 365 / 12,
+  year: 365,
+  one_time: 0
+};
+function periodDays(interval, count) {
+  return PERIOD_DAYS[interval] * count;
+}
+function intervalLabel(interval, count) {
+  if (interval === "one_time") return { period: "one-time", periodly: "one-time" };
+  if (interval === "month" && count === 3) return { period: "quarter", periodly: "quarterly" };
+  if (interval === "month" && count === 6) return { period: "6 months", periodly: "semiannually" };
+  if (interval === "week" && count === 2) return { period: "2 weeks", periodly: "biweekly" };
+  if (count === 1) {
+    const periodly = { day: "daily", week: "weekly", month: "monthly", year: "yearly" }[interval];
+    return { period: interval, periodly };
+  }
+  return { period: `${count} ${interval}s`, periodly: `every ${count} ${interval}s` };
+}
+function resolveOffering(input) {
+  const interval = input.interval ?? "one_time";
+  const count = input.intervalCount ?? 1;
+  const days = periodDays(interval, count);
+  const per = (targetDays) => days > 0 ? Math.round(input.amount * targetDays / days) : input.amount;
+  const label = intervalLabel(interval, count);
+  const trialDays = input.trialDays ?? 0;
+  const trialMinor = input.trialAmount ?? 0;
+  return {
+    id: input.id,
+    catalogKey: input.catalogKey ?? input.id,
+    name: input.name ?? input.id,
+    displayName: input.displayName ?? input.name ?? input.id,
+    provider: input.provider ?? "stripe",
+    currency: input.currency,
+    priceMinor: input.amount,
+    perDayMinor: per(1),
+    perWeekMinor: per(7),
+    perMonthMinor: per(365 / 12),
+    perYearMinor: per(365),
+    period: label.period,
+    periodly: label.periodly,
+    hasTrial: trialDays > 0 || trialMinor > 0,
+    trialDays,
+    trialMinor
+  };
+}
+function buildCatalog(inputs) {
+  return new Map(inputs.map((i) => [i.id, resolveOffering(i)]));
+}
+var EXPONENT_CACHE = /* @__PURE__ */ new Map();
+function currencyExponent(currency) {
+  const code = currency.toUpperCase();
+  const hit = EXPONENT_CACHE.get(code);
+  if (hit !== void 0) return hit;
+  let exp = 2;
+  try {
+    exp = new Intl.NumberFormat("en", { style: "currency", currency: code }).resolvedOptions().maximumFractionDigits ?? 2;
+  } catch {
+    exp = 2;
+  }
+  EXPONENT_CACHE.set(code, exp);
+  return exp;
+}
+function formatMoney(minor, currency, locale) {
+  const code = currency.toUpperCase();
+  const exp = currencyExponent(code);
+  const amount = minor / 10 ** exp;
+  let formatted;
+  try {
+    formatted = new Intl.NumberFormat(locale, { style: "currency", currency: code }).format(amount);
+  } catch {
+    formatted = `${code} ${amount.toFixed(exp)}`;
+  }
+  return { amount, minor, currency: code, formatted };
+}
+function formatOffering(r, locale) {
+  const m = (minor) => formatMoney(minor, r.currency, locale);
+  return {
+    id: r.id,
+    catalogKey: r.catalogKey,
+    name: r.name,
+    displayName: r.displayName,
+    provider: r.provider,
+    price: m(r.priceMinor),
+    period: r.period,
+    periodly: r.periodly,
+    perDay: m(r.perDayMinor),
+    perWeek: m(r.perWeekMinor),
+    perMonth: m(r.perMonthMinor),
+    perYear: m(r.perYearMinor),
+    hasTrial: r.hasTrial,
+    trialDays: r.trialDays,
+    trialPrice: r.hasTrial ? m(r.trialMinor) : null
+  };
+}
+
+// src/flow/spine.ts
+function readField(s, field) {
+  let cur = s;
+  for (const part of field.split(".")) {
+    if (cur == null) return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function evaluateCondition(cond, s) {
+  const val = readField(s, cond.field);
+  const { op, value } = cond;
+  switch (op) {
+    case "eq":
+      return val === value;
+    case "neq":
+      return val !== value;
+    case "in":
+      return Array.isArray(value) && value.includes(val);
+    case "gt":
+      return typeof val === "number" && typeof value === "number" && val > value;
+    case "gte":
+      return typeof val === "number" && typeof value === "number" && val >= value;
+    case "lt":
+      return typeof val === "number" && typeof value === "number" && val < value;
+    case "lte":
+      return typeof val === "number" && typeof value === "number" && val <= value;
+    case "contains":
+      if (typeof val === "string") return val.includes(String(value));
+      if (Array.isArray(val))
+        return val.includes(value);
+      return false;
+    case "exists":
+      return val !== void 0 && val !== null && val !== "";
+    case "empty":
+      return val === void 0 || val === null || val === "" || Array.isArray(val) && val.length === 0;
+    default:
+      return false;
+  }
+}
+function evaluateGate(gate, s) {
+  return typeof gate === "function" ? gate(s) : evaluateCondition(gate, s);
+}
+function resolveRoute(routes, s) {
+  if (!routes) return void 0;
+  for (const route of routes) {
+    if (!route.when || evaluateGate(route.when, s)) return route.to;
+  }
+  return void 0;
+}
+function pageMeta(meta) {
+  return meta;
+}
+var TYPE_GUARDS = {
+  paywall: { field: "user.email", op: "exists" },
+  upsell: { field: "user.email", op: "exists" }
+};
+function entryGuard(meta) {
+  return meta?.guard ?? (meta?.type ? TYPE_GUARDS[meta.type] : void 0);
+}
+function definePage(component) {
+  return component;
+}
+function nextPage(pages, currentKey, s) {
+  const idx = pages.findIndex((p) => p.key === currentKey);
+  if (idx === -1) return void 0;
+  const routed = resolveRoute(pages[idx].meta?.next, s);
+  if (routed) return routed;
+  return pages[idx + 1]?.key;
+}
+function outgoingKeys(pages, currentKey) {
+  const idx = pages.findIndex((p) => p.key === currentKey);
+  if (idx === -1) return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const route of pages[idx].meta?.next ?? []) out.add(route.to);
+  const linear = pages[idx + 1]?.key;
+  if (linear) out.add(linear);
+  return [...out];
+}
+function expectedPathLength(pages, startKey, s) {
+  const seen = /* @__PURE__ */ new Set();
+  let key = startKey;
+  let count = 0;
+  while (key && !seen.has(key)) {
+    seen.add(key);
+    count++;
+    if (pages.find((p) => p.key === key)?.meta?.type === "finish") break;
+    key = nextPage(pages, key, s);
+  }
+  return count;
+}
+function groupProgress(pages, startKey, currentKey, s) {
+  const path = [];
+  const seen = /* @__PURE__ */ new Set();
+  let key = startKey;
+  while (key && !seen.has(key)) {
+    seen.add(key);
+    const page = pages.find((p) => p.key === key);
+    path.push(page?.meta?.group);
+    if (page?.meta?.type === "finish") break;
+    key = nextPage(pages, key, s);
+  }
+  const found = [...seen].indexOf(currentKey);
+  const cursor = found === -1 ? 0 : found;
+  const order = [];
+  const tally = /* @__PURE__ */ new Map();
+  path.forEach((group, i) => {
+    if (!group) return;
+    let g = tally.get(group);
+    if (!g) {
+      g = { pageCount: 0, completedCount: 0 };
+      tally.set(group, g);
+      order.push(group);
+    }
+    g.pageCount++;
+    if (i < cursor) g.completedCount++;
+  });
+  const currentGroup = path[cursor];
+  const groups = order.map((key2) => ({
+    key: key2,
+    pageCount: tally.get(key2).pageCount,
+    completedCount: tally.get(key2).completedCount,
+    active: key2 === currentGroup
+  }));
+  const activeIndex = currentGroup ? order.indexOf(currentGroup) : -1;
+  const active = activeIndex >= 0 ? groups[activeIndex] : void 0;
+  const activeFraction = active && active.pageCount > 0 ? (active.completedCount + 1) / active.pageCount : 0;
+  return { groups, activeIndex, activeFraction };
+}
+function defineFunnel(def) {
+  return def;
+}
+function normalizeOfferings(offerings) {
+  if (!offerings) return [];
+  if (Array.isArray(offerings))
+    return offerings.map((k) => ({ slot: k, catalogKey: k }));
+  return Object.entries(offerings).map(([slot, catalogKey]) => ({
+    slot,
+    catalogKey: catalogKey ?? null
+  }));
+}
+function funnelCatalogKeys(offerings) {
+  return [
+    ...new Set(
+      normalizeOfferings(offerings).map((s) => s.catalogKey).filter((k) => !!k)
+    )
+  ];
+}
+
+// src/flow/experiments.ts
+function fnv1a(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+  }
+  return h >>> 0;
+}
+function hashToUnit(seed) {
+  return fnv1a(seed) / 4294967296;
+}
+function pickByWeight(weights, u) {
+  const entries = Object.entries(weights).filter(([, w]) => w > 0);
+  if (entries.length === 0) return Object.keys(weights)[0] ?? "";
+  const total = entries.reduce((sum, [, w]) => sum + w, 0);
+  const target = u * total;
+  let acc = 0;
+  for (const [key, w] of entries) {
+    acc += w;
+    if (target < acc) return key;
+  }
+  return entries[entries.length - 1][0];
+}
+function assignVariant(experimentId, seed, weights) {
+  return pickByWeight(weights, hashToUnit(`${experimentId}:${seed}`));
+}
+function bucketingSeed(context) {
+  return context.identity.visitorId ?? context.identity.customerId ?? null;
+}
+function parseSlotKey(key) {
+  const at = key.indexOf("@");
+  return at === -1 ? { slot: key } : { slot: key.slice(0, at), variant: key.slice(at + 1) };
+}
+function isVariantKey(key) {
+  return parseSlotKey(key).variant !== void 0;
+}
+function weightsOf(variants) {
+  const out = {};
+  for (const [label, v] of Object.entries(variants)) out[label] = v.weight;
+  return out;
+}
+function resolveExperiments(pages, experiments, seed) {
+  const assignments = {};
+  const render = {};
+  const experimentOf = {};
+  const versionOf = {};
+  if (seed) {
+    for (const exp of experiments) {
+      const label = assignVariant(exp.id, seed, weightsOf(exp.variants));
+      const arm = exp.variants[label];
+      if (!arm) continue;
+      assignments[exp.id] = label;
+      experimentOf[exp.slot] = exp.id;
+      if (exp.version !== void 0) versionOf[exp.id] = exp.version;
+      if (arm.page !== exp.slot) render[exp.slot] = arm.page;
+    }
+  }
+  const slotOf = {};
+  const activeKeys = [];
+  for (const p of pages) {
+    const { slot, variant } = parseSlotKey(p.key);
+    if (variant !== void 0) slotOf[p.key] = slot;
+    else activeKeys.push(p.key);
+  }
+  return { assignments, activeKeys, render, slotOf, experimentOf, versionOf };
+}
+
+// src/manifest/manifest.ts
+function isVariantNode(page) {
+  return isVariantKey(page.key);
+}
+function serializeGate(when) {
+  if (!when) return void 0;
+  if (typeof when === "function") return { kind: "predicate" };
+  return { kind: "declarative", condition: when };
+}
+function compileManifest(input) {
+  const { funnel, pages } = input;
+  const keys = new Set(pages.map((p) => p.key));
+  const manifestPages = pages.map((p, index) => ({
+    id: p.key,
+    key: p.key,
+    type: p.meta?.type ?? "default",
+    slug: p.meta?.slug ?? p.key,
+    index,
+    // Progress-bar group membership, carried additively (undefined when the page declares no group).
+    group: p.meta?.group,
+    variantOf: isVariantKey(p.key) ? parseSlotKey(p.key).slot : void 0,
+    // The effective entry guard (explicit meta.guard, else the page-type default), serialized so
+    // the renderer can evaluate a DECLARATIVE guard server-side (Option B, FIX 1). Predicate guards
+    // serialize to an opaque marker → the renderer falls back to live SSR for that deep-link.
+    entryGuard: serializeGate(entryGuard(p.meta)),
+    // Prerender opt-out: `dynamic: true` OR `prerender: false` (a page whose STRUCTURE depends on
+    // sessionValues — Option B, FIX 2). Undefined stays undefined (prerendered, the default).
+    dynamic: p.meta?.dynamic === true || p.meta?.prerender === false ? true : void 0
+  }));
+  const edges = [];
+  const badTargets = [];
+  const nextAnchor = (from) => {
+    for (let j = from + 1; j < pages.length; j++) {
+      if (!isVariantNode(pages[j])) return pages[j];
+    }
+    return void 0;
+  };
+  pages.forEach((p, i) => {
+    if (isVariantNode(p)) {
+      for (const route of p.meta?.next ?? []) {
+        if (!keys.has(route.to)) {
+          badTargets.push({ from: p.key, to: route.to });
+          continue;
+        }
+        edges.push({ from: p.key, to: route.to, kind: "branch", variant: true, condition: serializeGate(route.when) });
+      }
+      return;
+    }
+    const routes = p.meta?.next ?? [];
+    let hasUnconditional = false;
+    for (const route of routes) {
+      if (!keys.has(route.to)) {
+        badTargets.push({ from: p.key, to: route.to });
+        continue;
+      }
+      edges.push({ from: p.key, to: route.to, kind: "branch", condition: serializeGate(route.when) });
+      if (!route.when) hasUnconditional = true;
+    }
+    const next = nextAnchor(i);
+    if (!hasUnconditional && next && p.meta?.type !== "finish") {
+      edges.push({ from: p.key, to: next.key, kind: "linear" });
+    }
+  });
+  const startPage = pages.find((p) => !isVariantNode(p));
+  const start = startPage?.key ?? null;
+  const variantKeys = new Set(pages.filter(isVariantNode).map((p) => p.key));
+  const offeringSlots = normalizeOfferings(funnel.offerings);
+  const validation = validate(manifestPages, edges, badTargets, start, variantKeys, offeringSlots, input.offeringRefs);
+  return {
+    id: funnel.id,
+    pages: manifestPages,
+    flow: { start, nodes: manifestPages.map((p) => p.id), edges },
+    offerings: funnelCatalogKeys(funnel.offerings),
+    offeringSlots,
+    offeringRefs: input.offeringRefs,
+    // Carry the funnel.ts `checkout:` bundle + the scanned checkout-surface usage for the publish
+    // capability gate. Both are provider-agnostic here (the SDK can't resolve offering→provider);
+    // the API gate combines them with the DB-resolved provider to run the (provider × surface) matrix.
+    checkout: funnel.checkout,
+    checkoutRefs: input.checkoutRefs,
+    locales: funnel.locales,
+    validation
+  };
+}
+function validate(pages, edges, badTargets, start, variantKeys, slots, offeringRefs) {
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const e of edges) outgoing.set(e.from, (outgoing.get(e.from) ?? 0) + 1);
+  const deadEnds = pages.filter((p) => p.type !== "finish" && !variantKeys.has(p.id) && !(outgoing.get(p.id) > 0)).map((p) => p.id);
+  const reachable = /* @__PURE__ */ new Set();
+  if (start) {
+    const adj = /* @__PURE__ */ new Map();
+    for (const e of edges) {
+      const list = adj.get(e.from);
+      if (list) list.push(e.to);
+      else adj.set(e.from, [e.to]);
+    }
+    for (const p of pages) {
+      if (p.variantOf === void 0) continue;
+      const list = adj.get(p.variantOf);
+      if (list) list.push(p.id);
+      else adj.set(p.variantOf, [p.id]);
+    }
+    const stack = [start];
+    while (stack.length) {
+      const id = stack.pop();
+      if (reachable.has(id)) continue;
+      reachable.add(id);
+      for (const to of adj.get(id) ?? []) stack.push(to);
+    }
+  }
+  const unreachable = pages.filter((p) => !variantKeys.has(p.id) && !reachable.has(p.id)).map((p) => p.id);
+  const missingEmailCapture = !pages.some((p) => p.type === "email-capture");
+  const seen = /* @__PURE__ */ new Set();
+  const duplicateKeys = [];
+  for (const p of pages) {
+    if (seen.has(p.key) && !duplicateKeys.includes(p.key)) duplicateKeys.push(p.key);
+    seen.add(p.key);
+  }
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const p of pages) {
+    if (variantKeys.has(p.id)) continue;
+    const list = bySlug.get(p.slug);
+    if (list) list.push(p.id);
+    else bySlug.set(p.slug, [p.id]);
+  }
+  const slugCollisions = [...bySlug.entries()].filter(([, ids]) => ids.length > 1).map(([slug, ids]) => ({ slug, pages: ids }));
+  const flowKeys = new Set(pages.filter((p) => !variantKeys.has(p.id)).map((p) => p.key));
+  const orphanVariants = pages.filter((p) => p.variantOf !== void 0 && !flowKeys.has(p.variantOf)).map((p) => p.id);
+  const noReachableFinish = start !== null && !pages.some((p) => p.type === "finish" && reachable.has(p.id));
+  const declaredSlots = new Set(slots.map((s) => s.slot));
+  const assignedSlots = new Set(slots.filter((s) => s.catalogKey).map((s) => s.slot));
+  const refs = offeringRefs ?? [];
+  const unknownOfferingRefs = [...new Set(refs.filter((r) => !declaredSlots.has(r)))];
+  const unassignedSlots = [...new Set(refs.filter((r) => declaredSlots.has(r) && !assignedSlots.has(r)))];
+  return {
+    // Original hard errors AND the structural ones; slug collisions stay a warning.
+    ok: deadEnds.length === 0 && unreachable.length === 0 && badTargets.length === 0 && !missingEmailCapture && duplicateKeys.length === 0 && orphanVariants.length === 0 && !noReachableFinish && unknownOfferingRefs.length === 0 && unassignedSlots.length === 0,
+    deadEnds,
+    unreachable,
+    badTargets,
+    missingEmailCapture,
+    duplicateKeys,
+    slugCollisions,
+    orphanVariants,
+    noReachableFinish,
+    unknownOfferingRefs,
+    unassignedSlots
+  };
+}
+
+export { assignVariant, bucketingSeed, buildCatalog, compileManifest, currencyExponent, defineFunnel, definePage, entryGuard, evaluateCondition, evaluateGate, expectedPathLength, fnv1a, formatMoney, formatOffering, funnelCatalogKeys, groupProgress, hashToUnit, isRtl, isVariantKey, nextPage, normalizeOfferings, outgoingKeys, pageMeta, parseSlotKey, pickByWeight, resolveExperiments, resolveLocale, resolveOffering, resolveRoute, weightsOf };
+//# sourceMappingURL=chunk-SXENKZ4U.js.map
+//# sourceMappingURL=chunk-SXENKZ4U.js.map