@wix/himalaya-cli 0.1141.0 → 0.1143.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/iap.mjs

@@ -13,6 +13,507 @@ function dispatch(handlerId, params, _options) {
   return himalaya.dispatch(handlerId, stringParams);
 }
 
+// ../../core/sdk/iap/src/delivery.ts
+var MAX_AUTOMATIC_ATTEMPTS = 5;
+var MAX_RETRY_DELAY_MS = 6e4;
+var BASE_RETRY_DELAY_MS = 1e3;
+var UNAVAILABLE_CODES = /* @__PURE__ */ new Set(["unsupported", "unavailable", "notEnabled"]);
+function createPurchaseCoordinator(deps) {
+  const items = /* @__PURE__ */ new Map();
+  const queue = createSerialQueue();
+  const store = guardStore(deps.store);
+  let outcome = "idle";
+  let purchasing = false;
+  let signInPrompt = false;
+  let unavailable = null;
+  let pendingApproval = null;
+  let errorCode = null;
+  let errorFromReconcile = false;
+  let unfinishedCount = null;
+  let generation = deps.session.current().generation;
+  let staleSignal = createSignal();
+  let started = false;
+  let disposed = false;
+  const unsubscribe = deps.session.subscribe(onSessionNotified);
+  function start() {
+    started = true;
+    return reconcile();
+  }
+  function purchase2(catalogRef) {
+    onSessionNotified();
+    const requestedBy = deps.session.current();
+    const name = `purchase:${requestedBy.generation}:${catalogRef}`;
+    return runJob(name, () => runPurchase(requestedBy, catalogRef), { joinRunning: true }).then(([dropped, state]) => dropped ? { ...state, errorCode: "sessionChanged" } : state);
+  }
+  function reconcile() {
+    resetIfSessionChanged();
+    return enqueue("reconcile", runReconcile);
+  }
+  function retry() {
+    resetIfSessionChanged();
+    return enqueue("retry", runRetry);
+  }
+  function tick() {
+    if (resetIfSessionChanged() && started) return reconcile();
+    return enqueue("tick", runDue);
+  }
+  function getState() {
+    if (disposed || !sessionMatches()) return { phase: "idle", errorCode: null, items: [], unfinishedCount: null, nextWakeAt: null };
+    const snapshot = [...items.values()].map((item) => ({ ...item.state }));
+    const due = snapshot.map((item) => item.nextAttemptAt).filter((at) => at !== null);
+    return { phase: currentPhase(), errorCode: errorCode ?? unavailable?.code ?? null, items: snapshot, unfinishedCount, nextWakeAt: due.length > 0 ? Math.min(...due) : null };
+  }
+  function dispose() {
+    disposed = true;
+    unsubscribe();
+    staleSignal.fire();
+  }
+  async function runPurchase(session, catalogRef) {
+    if (!isCurrent(session)) return !disposed;
+    setError(null, false);
+    outcome = "idle";
+    pendingApproval = null;
+    unavailable = null;
+    releaseSignIn();
+    if (session.kind !== "member") {
+      requireSignIn();
+      return false;
+    }
+    const context = await purchaseContext(session, catalogRef);
+    if (!isCurrent(session)) return !disposed;
+    if (!context) return false;
+    purchasing = true;
+    publish();
+    const { productId, appAccountToken } = context;
+    const result = await store.purchaseForVerification({ productId, appAccountToken });
+    purchasing = false;
+    if (!isCurrent(session)) return !disposed;
+    if (result.status === "purchased") await deliverPurchase(session, result.transaction, context);
+    else if (result.status === "failed") failStore(result.code, false);
+    else if (result.status === "pending") {
+      if (!await awaitApproval(session, context)) return !disposed;
+    } else setOutcome("cancelled");
+    return false;
+  }
+  async function deliverPurchase(session, transaction, context) {
+    const item = upsert(transaction, null);
+    applyDelivered(await deliver(session, [item], context));
+    await enumerate(session);
+    publish();
+  }
+  async function runReconcile() {
+    resetIfSessionChanged();
+    const session = deps.session.current();
+    const listing = await enumerate(session);
+    if (listing === "stale") return;
+    if (session.kind !== "member") return requireSignIn();
+    if (listing === "listed") clearReconcileProblem();
+    const now = deps.clock.now();
+    const eligible = itemsWhere((state) => isAwaitingDelivery(state) && (state.nextAttemptAt === null || state.nextAttemptAt <= now));
+    eligible.forEach(restartAttemptBudget);
+    await settleDelivery(session, await deliver(session, eligible));
+  }
+  async function settleDelivery(session, delivered) {
+    applyDelivered(delivered);
+    if (delivered.finished) await enumerate(session);
+    publish();
+  }
+  function applyDelivered(delivered) {
+    if (delivered.confirmedProducts.length === 0) return;
+    if (outcome === "cancelled") outcome = "idle";
+    if (!delivered.signInLost) releaseSignIn();
+  }
+  function releaseSignIn() {
+    if (!signInPrompt) return;
+    signInPrompt = false;
+    const now = deps.clock.now();
+    for (const item of items.values()) {
+      if (item.state.access === "signInRequired") Object.assign(item.state, { access: "waitingToRetry", attempts: 0, nextAttemptAt: now });
+    }
+  }
+  function clearReconcileProblem() {
+    if (unavailable?.from === "reconcile") unavailable = null;
+    if (errorFromReconcile) setError(null, false);
+  }
+  async function runRetry() {
+    releaseSignIn();
+    for (const item of items.values()) unblock(item.state);
+    await runReconcile();
+  }
+  async function runDue() {
+    if (resetIfSessionChanged()) return started ? runReconcile() : void 0;
+    const session = memberSession();
+    const now = deps.clock.now();
+    const due = itemsWhere((state) => state.nextAttemptAt !== null && state.nextAttemptAt <= now);
+    if (!session || due.length === 0) return;
+    await settleDelivery(session, await deliver(session, due));
+  }
+  async function deliver(session, batch, known) {
+    const needProof = batch.filter((item) => item.state.access !== "confirmed");
+    const context = known ?? (needProof.length > 0 ? await memberContext(session, needProof) : void 0);
+    const delivered = noDelivery();
+    for (const item of batch) {
+      if (!isCurrent(session)) return noDelivery();
+      const wasConfirmed = item.state.access === "confirmed";
+      if (delivered.signInLost && !wasConfirmed) {
+        blockWithoutSession(item, context);
+        continue;
+      }
+      if (await deliverItem(session, item, context)) delivered.finished = true;
+      if (!wasConfirmed && item.state.access === "confirmed") delivered.confirmedProducts.push(item.state.productId);
+      if (item.state.access === "signInRequired") delivered.signInLost = true;
+    }
+    return delivered;
+  }
+  function blockWithoutSession(item, context) {
+    const foreign = context !== void 0 && !sameAccount(item.transaction.appAccountToken, context.appAccountToken);
+    block(item.state, foreign ? "ownershipConflict" : "signInRequired", null);
+  }
+  async function deliverItem(session, item, context) {
+    if (item.state.access !== "confirmed") {
+      if (!context || !await confirmAccess(session, item, context)) return false;
+    }
+    return complete(session, item);
+  }
+  async function confirmAccess(session, item, context) {
+    if (!sameAccount(item.transaction.appAccountToken, context.appAccountToken)) {
+      block(item.state, "ownershipConflict", null);
+      return false;
+    }
+    updateItem(item, { access: "confirming", nextAttemptAt: null });
+    const settled = await settle(session, () => deps.backend.submitProof(session, item.transaction));
+    if (settled.kind === "stale") return false;
+    if (settled.kind === "error") return recordFailedAttempt(item, void 0);
+    return applySubmission(item, settled.value, context.scopeKey);
+  }
+  function applySubmission(item, raw, scopeKey) {
+    if (!isObject(raw)) return block(item.state, "rejected", "invalidResponse");
+    switch (raw.status) {
+      case "processed":
+      case "alreadyProcessed":
+        if (!acknowledges(raw.acknowledgement, item.transaction, scopeKey)) return block(item.state, "rejected", "invalidResponse");
+        Object.assign(item.state, { access: "confirmed", nextAttemptAt: null, errorCode: null });
+        return true;
+      case "retryable":
+        return recordFailedAttempt(item, retryAfter(raw.retryAfterMs));
+      case "authRequired":
+        signInPrompt = true;
+        return block(item.state, "signInRequired", null);
+      case "ownershipConflict":
+        return block(item.state, "ownershipConflict", null);
+      case "rejected":
+        return block(item.state, "rejected", "proofRejected");
+      default:
+        return block(item.state, "rejected", "invalidResponse");
+    }
+  }
+  async function complete(session, item) {
+    if (!isCurrent(session)) return false;
+    const result = await store.finishTransaction({ transactionId: item.transaction.transactionId });
+    if (!isCurrent(session)) return false;
+    if (result.status === "failed") {
+      item.state.completion = "retryRequired";
+      recordFailedAttempt(item, void 0);
+      return false;
+    }
+    Object.assign(item.state, { completion: result.status, held: false, nextAttemptAt: null });
+    return result.status === "finished";
+  }
+  function recordFailedAttempt(item, retryAfterMs) {
+    const state = item.state;
+    state.attempts += 1;
+    if (state.access !== "confirmed") state.access = "waitingToRetry";
+    state.nextAttemptAt = state.attempts >= MAX_AUTOMATIC_ATTEMPTS ? null : deps.clock.now() + retryDelay(state.attempts, retryAfterMs);
+    return false;
+  }
+  function retryDelay(attempts, retryAfterMs) {
+    if (retryAfterMs !== void 0) return Math.min(retryAfterMs, MAX_RETRY_DELAY_MS);
+    const base = Math.min(BASE_RETRY_DELAY_MS * 2 ** (attempts - 1), MAX_RETRY_DELAY_MS);
+    return base + Math.max(0, deps.jitter?.(base) ?? 0);
+  }
+  async function purchaseContext(session, catalogRef) {
+    const settled = await settle(session, () => deps.backend.getPurchaseContext(session, catalogRef));
+    if (settled.kind === "stale") return null;
+    const decoded = decodeContext(settled, isPurchaseContext);
+    if (decoded.kind === "ok") return decoded.context;
+    if (decoded.kind === "signInRequired") requireSignIn();
+    else failContext(decoded.kind);
+    return null;
+  }
+  async function memberContext(session, waiting) {
+    const settled = await settle(session, () => deps.backend.getMemberContext(session));
+    if (settled.kind === "stale") return void 0;
+    const decoded = decodeContext(settled, isMemberContext);
+    if (decoded.kind === "ok") return decoded.context;
+    if (decoded.kind === "rejected") setError("contextRejected", true);
+    if (decoded.kind === "signInRequired") signInPrompt = true;
+    for (const item of waiting) {
+      if (decoded.kind === "unavailable") recordFailedAttempt(item, decoded.retryAfterMs);
+      else if (decoded.kind === "rejected") block(item.state, "waitingToRetry", "contextRejected");
+      else block(item.state, "signInRequired", null);
+    }
+    return void 0;
+  }
+  async function enumerate(session, { quiet = false } = {}) {
+    if (!isCurrent(session)) return "stale";
+    const result = await store.getUnfinishedTransactions();
+    if (!isCurrent(session)) return "stale";
+    if (result.status !== "ok") {
+      unfinishedCount = null;
+      if (!quiet) failStore(result.code, true);
+      return "failed";
+    }
+    const held = new Set(result.transactions.map((transaction) => upsert(transaction, true)));
+    for (const item of items.values()) if (!held.has(item)) item.state.held = false;
+    unfinishedCount = result.transactions.length;
+    return "listed";
+  }
+  function upsert(transaction, held) {
+    const key = identityOf(transaction);
+    const existing = items.get(key);
+    if (existing) {
+      existing.transaction = transaction;
+      if (held !== null) existing.state.held = held;
+      return existing;
+    }
+    if (pendingApproval?.productId === transaction.productId && !pendingApproval.known.has(key) && sameAccount(transaction.appAccountToken, pendingApproval.token)) {
+      pendingApproval = null;
+      if (outcome === "awaitingApproval") outcome = "idle";
+    }
+    const item = { transaction, state: newItemState(transaction, held) };
+    items.set(key, item);
+    return item;
+  }
+  function onSessionNotified() {
+    if (resetIfSessionChanged() && started) void reconcile();
+  }
+  function resetIfSessionChanged() {
+    const next = deps.session.current().generation;
+    if (disposed || next === generation) return false;
+    generation = next;
+    staleSignal.fire();
+    staleSignal = createSignal();
+    items.clear();
+    outcome = "idle";
+    purchasing = false;
+    signInPrompt = false;
+    unavailable = null;
+    pendingApproval = null;
+    unfinishedCount = null;
+    setError(null, false);
+    publish();
+    return true;
+  }
+  function memberSession() {
+    const session = deps.session.current();
+    return session.kind === "member" ? session : null;
+  }
+  function sessionMatches() {
+    return deps.session.current().generation === generation;
+  }
+  function isCurrent(session) {
+    return !disposed && session.generation === generation && sessionMatches();
+  }
+  async function settle(session, call) {
+    const stale = staleSignal.waiter();
+    try {
+      const pending = Promise.resolve().then(() => {
+        if (!isCurrent(session)) throw ABANDONED;
+        return call();
+      });
+      const settled = await Promise.race([pending.then((value) => ({ kind: "value", value })), stale.fired.then(() => STALE)]);
+      return isCurrent(session) ? settled : STALE;
+    } catch {
+      return isCurrent(session) ? { kind: "error" } : STALE;
+    } finally {
+      stale.cancel();
+    }
+  }
+  function runJob(name, run, options = {}) {
+    return queue.run(name, () => disposed ? Promise.resolve(void 0) : run(), options).then((result) => [result, getState()]);
+  }
+  function enqueue(name, run) {
+    return runJob(name, run).then(([, state]) => state);
+  }
+  function itemsWhere(predicate) {
+    return [...items.values()].filter((item) => predicate(item.state));
+  }
+  function updateItem(item, patch) {
+    Object.assign(item.state, patch);
+    publish();
+  }
+  function requireSignIn() {
+    for (const item of items.values()) {
+      if (isAwaitingDelivery(item.state) && item.state.access !== "confirmed") block(item.state, "signInRequired", null);
+    }
+    signInPrompt = true;
+    publish();
+  }
+  function failContext(reason) {
+    setError(reason === "rejected" ? "contextRejected" : "contextUnavailable", false);
+    publish();
+  }
+  function failStore(code, fromReconcile) {
+    setError(code, fromReconcile);
+    if (UNAVAILABLE_CODES.has(code) && unavailable?.from !== "purchase") {
+      unavailable = { from: fromReconcile ? "reconcile" : "purchase", code };
+    }
+    publish();
+  }
+  async function awaitApproval(session, context) {
+    if (await enumerate(session, { quiet: true }) === "stale") return false;
+    const known = new Set([...items.keys()].filter((key) => items.get(key).state.productId === context.productId));
+    pendingApproval = { productId: context.productId, token: context.appAccountToken, known };
+    setOutcome("awaitingApproval");
+    return true;
+  }
+  function setOutcome(next) {
+    outcome = next;
+    publish();
+  }
+  function currentPhase() {
+    if (purchasing) return "purchasing";
+    if (unavailable?.from === "purchase") return "unavailable";
+    if (signInPrompt) return "signInRequired";
+    if (unavailable?.from === "reconcile") return "unavailable";
+    return outcome;
+  }
+  function setError(code, fromReconcile) {
+    errorCode = code;
+    errorFromReconcile = code !== null && fromReconcile;
+  }
+  function publish() {
+    if (!disposed && sessionMatches()) deps.onState?.(getState());
+  }
+  return { start, purchase: purchase2, reconcile, retry, tick, getState, dispose };
+}
+var noDelivery = () => ({ finished: false, confirmedProducts: [], signInLost: false });
+var STALE = { kind: "stale" };
+var ABANDONED = { abandoned: true };
+async function storeCall(call) {
+  try {
+    return await call();
+  } catch {
+    return { status: "failed", code: "storeError" };
+  }
+}
+function guardStore(store) {
+  return {
+    purchaseForVerification: (input) => storeCall(() => store.purchaseForVerification(input)),
+    getUnfinishedTransactions: () => storeCall(() => store.getUnfinishedTransactions()),
+    finishTransaction: (input) => storeCall(() => store.finishTransaction(input))
+  };
+}
+function identityOf(transaction) {
+  return `${transaction.store}:${transaction.environment}:${transaction.transactionId}`;
+}
+function newItemState(transaction, held) {
+  return {
+    productId: transaction.productId,
+    environment: transaction.environment,
+    held,
+    access: "pending",
+    completion: "pending",
+    attempts: 0,
+    nextAttemptAt: null,
+    errorCode: null
+  };
+}
+function isAwaitingDelivery(state) {
+  if (state.access === "confirmed") return state.completion === "pending" || state.completion === "retryRequired";
+  return state.access === "pending" || state.access === "waitingToRetry" || state.access === "signInRequired";
+}
+function restartAttemptBudget(item) {
+  item.state.attempts = 0;
+}
+function unblock(state) {
+  if (state.access !== "confirmed") Object.assign(state, { access: "pending", errorCode: null });
+  Object.assign(state, { attempts: 0, nextAttemptAt: null });
+}
+function block(state, access, errorCode) {
+  Object.assign(state, { access, errorCode, nextAttemptAt: null });
+  return false;
+}
+function sameAccount(transactionToken, memberToken) {
+  return transactionToken !== null && transactionToken.toLowerCase() === memberToken.toLowerCase();
+}
+function acknowledges(acknowledgement, transaction, scopeKey) {
+  return isObject(acknowledgement) && acknowledgement.transactionId === transaction.transactionId && acknowledgement.productId === transaction.productId && acknowledgement.environment === transaction.environment && acknowledgement.scopeKey === scopeKey;
+}
+function decodeContext(settled, isContext) {
+  const raw = settled.kind === "value" ? settled.value : null;
+  if (!isObject(raw)) return { kind: "unavailable" };
+  if (raw.status === "ok" && isContext(raw.context)) return { kind: "ok", context: raw.context };
+  if (raw.status === "authRequired") return { kind: "signInRequired" };
+  if (raw.status === "rejected") return { kind: "rejected" };
+  return { kind: "unavailable", retryAfterMs: retryAfter(raw.retryAfterMs) };
+}
+function isPurchaseContext(value) {
+  return isMemberContext(value) && isObject(value) && isNonEmpty(value.productId);
+}
+function isMemberContext(value) {
+  return isObject(value) && isNonEmpty(value.appAccountToken) && isNonEmpty(value.scopeKey);
+}
+function retryAfter(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function isNonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function createSignal() {
+  const listeners = /* @__PURE__ */ new Set();
+  let hasFired = false;
+  return {
+    fire() {
+      hasFired = true;
+      for (const listener of listeners) listener();
+      listeners.clear();
+    },
+    waiter() {
+      let listener = () => {
+      };
+      const fired = new Promise((resolve) => {
+        listener = resolve;
+      });
+      if (hasFired) listener();
+      else listeners.add(listener);
+      return { fired, cancel: () => {
+        listeners.delete(listener);
+      } };
+    }
+  };
+}
+function createSerialQueue() {
+  let tail = Promise.resolve();
+  const waiting = /* @__PURE__ */ new Map();
+  const running = /* @__PURE__ */ new Map();
+  async function execute(name, self, job) {
+    waiting.delete(name);
+    running.set(name, self);
+    try {
+      return await job();
+    } catch {
+      return void 0;
+    } finally {
+      running.delete(name);
+    }
+  }
+  return {
+    /** Callers joined onto a shared job all receive that job's result. */
+    run(name, job, { joinRunning = false }) {
+      const shared = waiting.get(name) ?? (joinRunning ? running.get(name) : void 0);
+      if (shared) return shared;
+      const scheduled = tail.then(() => execute(name, scheduled, job));
+      waiting.set(name, scheduled);
+      tail = scheduled;
+      return scheduled;
+    }
+  };
+}
+
 // ../../core/sdk/iap/src/index.ts
 async function getPaywallConfig() {
   const r = await dispatch("capability.iap.getPaywallConfig");
@@ -81,15 +582,16 @@ async function finishTransaction(input) {
   if (result?.status === "finished" || result?.status === "notFound") return { status: result.status };
   return decodeFailure(result);
 }
+var appleManagedStore = { purchaseForVerification, getUnfinishedTransactions, finishTransaction };
 var transactionErrors = /* @__PURE__ */ new Set(["unsupported", "unavailable", "invalidArgument", "invalidResponse", "notEnabled", "unsupportedProductType", "unknownProduct", "verificationFailed", "persistenceFailed", "ownershipConflict", "storeError", "busy"]);
 var failure = (code) => ({ status: "failed", code });
 var nonempty = (value) => typeof value === "string" && value.trim().length > 0;
 var isUUID = (value) => typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value) && value.length === 36;
-var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isObject2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 async function managedDispatch(invoke) {
   try {
     const value = await invoke();
-    return isObject(value) ? value : null;
+    return isObject2(value) ? value : null;
   } catch {
     return failure("unavailable");
   }
@@ -98,7 +600,7 @@ function decodeFailure(value) {
   return value?.status === "failed" && transactionErrors.has(value.code) ? failure(value.code) : failure("invalidResponse");
 }
 function isAppleTransaction(value) {
-  if (!isObject(value)) return false;
+  if (!isObject2(value)) return false;
   return value.store === "apple" && typeof value.signedTransaction === "string" && /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(value.signedTransaction) && nonempty(value.transactionId) && nonempty(value.originalTransactionId) && nonempty(value.productId) && (value.appAccountToken === null || isUUID(value.appAccountToken)) && ["production", "sandbox", "xcode", "unknown"].includes(value.environment);
 }
 function decodeTransaction(value) {
@@ -106,7 +608,11 @@ function decodeTransaction(value) {
   return { store, signedTransaction, transactionId, originalTransactionId, productId, appAccountToken, environment };
 }
 export {
+  MAX_AUTOMATIC_ATTEMPTS,
+  MAX_RETRY_DELAY_MS,
+  appleManagedStore,
   consume,
+  createPurchaseCoordinator,
   entitlements,
   finishTransaction,
   getPaywallConfig,