@riverbankcms/sdk 0.72.0 → 0.75.0

package/dist/client/chunk-WJXXNDSE.mjs

@@ -0,0 +1,245 @@
+"use client";
+import { assertNever } from './chunk-FU2QRZMX.mjs';
+import { useState, useEffect, useReducer, useRef, useCallback } from 'react';
+
+function useDiscountCodeUi(options) {
+  const [discountUiOpen, setDiscountUiOpen] = useState(false);
+  const [discountCode, setDiscountCode] = useState("");
+  const [discountsAvailable, setDiscountsAvailable] = useState(false);
+  const [manualCodeEntryAllowed, setManualCodeEntryAllowed] = useState(false);
+  const [autoAppliedDiscount, setAutoAppliedDiscount] = useState(null);
+  const [discountsAvailableLoading, setDiscountsAvailableLoading] = useState(false);
+  useEffect(() => {
+    let cancelled = false;
+    async function checkDiscountAvailability() {
+      if (!options.discountContext) {
+        setDiscountsAvailable(false);
+        setManualCodeEntryAllowed(false);
+        setAutoAppliedDiscount(null);
+        setDiscountsAvailableLoading(false);
+        setDiscountUiOpen(false);
+        setDiscountCode("");
+        return;
+      }
+      setDiscountsAvailableLoading(true);
+      try {
+        const res = await options.api.getDiscountsAvailable({
+          context: options.discountContext,
+          subtotalCents: options.subtotalCents
+        });
+        if (cancelled) return;
+        setDiscountsAvailable(res.hasDiscounts);
+        setManualCodeEntryAllowed(res.manualCodeEntryAllowed);
+        setAutoAppliedDiscount(res.autoAppliedDiscount);
+        if (!res.hasDiscounts || !res.manualCodeEntryAllowed) {
+          setDiscountUiOpen(false);
+          setDiscountCode("");
+        }
+      } catch {
+        if (cancelled) return;
+        setDiscountsAvailable(false);
+        setManualCodeEntryAllowed(false);
+        setAutoAppliedDiscount(null);
+        setDiscountUiOpen(false);
+        setDiscountCode("");
+      } finally {
+        if (!cancelled) setDiscountsAvailableLoading(false);
+      }
+    }
+    checkDiscountAvailability();
+    return () => {
+      cancelled = true;
+    };
+  }, [options.api, options.discountContext, options.subtotalCents]);
+  return {
+    discountUiOpen,
+    setDiscountUiOpen,
+    discountCode,
+    setDiscountCode,
+    discountsAvailable,
+    manualCodeEntryAllowed,
+    autoAppliedDiscount,
+    discountsAvailableLoading
+  };
+}
+
+// ../blocks/src/system/runtime/hooks/usePolling.state.ts
+function createInitialPollingState() {
+  return {
+    tag: "idle",
+    result: null,
+    error: null
+  };
+}
+function pollingReducer(state, action) {
+  switch (action.type) {
+    case "polling-went-idle":
+      return createInitialPollingState();
+    case "polling-reset":
+      return {
+        tag: "polling",
+        result: null,
+        error: null
+      };
+    case "polling-progressed":
+      return {
+        tag: "polling",
+        result: action.result,
+        error: null
+      };
+    case "polling-completed":
+      return {
+        tag: "completed",
+        result: action.result,
+        error: null
+      };
+    case "polling-failed":
+      return {
+        tag: "failed",
+        result: action.result,
+        error: null
+      };
+    case "polling-request-failed":
+      switch (state.tag) {
+        case "idle":
+          return {
+            tag: "polling",
+            result: null,
+            error: action.error
+          };
+        case "polling":
+          return {
+            tag: "polling",
+            result: state.result,
+            error: action.error
+          };
+        case "completed":
+        case "failed":
+        case "timeout":
+          return state;
+        default:
+          return assertNever(state);
+      }
+    case "polling-timed-out":
+      return {
+        tag: "timeout",
+        result: state.result,
+        error: new Error("Polling timed out")
+      };
+    default:
+      return assertNever(action);
+  }
+}
+
+// ../blocks/src/system/runtime/hooks/usePolling.ts
+var DEFAULT_MAX_ATTEMPTS = 10;
+var DEFAULT_POLL_INTERVAL = 1e3;
+function usePolling(config) {
+  const [state, dispatch] = useReducer(
+    pollingReducer,
+    void 0,
+    createInitialPollingState
+  );
+  const attemptsRef = useRef(0);
+  const timeoutRef = useRef(null);
+  const isPollingRef = useRef(false);
+  const isActiveRef = useRef(false);
+  const generationRef = useRef(0);
+  const configRef = useRef(config);
+  configRef.current = config;
+  const cleanup = useCallback(() => {
+    isActiveRef.current = false;
+    generationRef.current += 1;
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+    isPollingRef.current = false;
+  }, []);
+  const resetState = useCallback(() => {
+    dispatch({ type: "polling-reset" });
+    attemptsRef.current = 0;
+  }, []);
+  const poll = useCallback(async () => {
+    const cfg = configRef.current;
+    if (!cfg) return true;
+    if (isPollingRef.current) return false;
+    const maxAttempts = cfg.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+    if (attemptsRef.current >= maxAttempts) {
+      dispatch({ type: "polling-timed-out" });
+      cleanup();
+      return true;
+    }
+    isPollingRef.current = true;
+    attemptsRef.current += 1;
+    const generation = generationRef.current;
+    try {
+      const data = await cfg.pollFn();
+      if (generation !== generationRef.current || !isActiveRef.current) {
+        isPollingRef.current = false;
+        return true;
+      }
+      if (cfg.isFailed?.(data)) {
+        dispatch({ type: "polling-failed", result: data });
+        cleanup();
+        return true;
+      }
+      if (cfg.isComplete(data)) {
+        dispatch({ type: "polling-completed", result: data });
+        cleanup();
+        return true;
+      }
+      dispatch({ type: "polling-progressed", result: data });
+      isPollingRef.current = false;
+      return false;
+    } catch (err) {
+      if (generation !== generationRef.current || !isActiveRef.current) {
+        isPollingRef.current = false;
+        return true;
+      }
+      if (err instanceof Error) {
+        dispatch({ type: "polling-request-failed", error: err });
+      }
+      isPollingRef.current = false;
+      return false;
+    }
+  }, [cleanup]);
+  const schedulePoll = useCallback(() => {
+    if (!isActiveRef.current) return;
+    const cfg = configRef.current;
+    const pollInterval = cfg?.interval ?? DEFAULT_POLL_INTERVAL;
+    const doPoll = async () => {
+      const shouldStop = await poll();
+      if (!shouldStop && isActiveRef.current) {
+        timeoutRef.current = setTimeout(doPoll, pollInterval);
+      }
+    };
+    doPoll();
+  }, [poll]);
+  useEffect(() => {
+    if (!config) {
+      cleanup();
+      dispatch({ type: "polling-went-idle" });
+      return;
+    }
+    resetState();
+    isActiveRef.current = true;
+    schedulePoll();
+    return cleanup;
+  }, [config, cleanup, resetState, schedulePoll]);
+  const retry = useCallback(() => {
+    if (!configRef.current) return;
+    cleanup();
+    resetState();
+    isActiveRef.current = true;
+    schedulePoll();
+  }, [cleanup, resetState, schedulePoll]);
+  return {
+    status: config ? state.tag : "idle",
+    result: config ? state.result : null,
+    error: config ? state.error : null,
+    retry
+  };
+}
+
+export { useDiscountCodeUi, usePolling };

package/dist/client/chunk-YLMKMCSJ.mjs

@@ -0,0 +1,86 @@
+"use client";
+import { useRef, useState, useEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// ../altcha/src/AltchaWidget.tsx
+function AltchaWidget({
+  challengeUrl,
+  onSolutionChange,
+  auto = true,
+  hidelogo = false,
+  className
+}) {
+  const containerRef = useRef(null);
+  const [isLoaded, setIsLoaded] = useState(false);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    let widget = null;
+    import('./altcha-LIGLPZS5.mjs').then(() => {
+      if (!containerRef.current) return;
+      widget = document.createElement("altcha-widget");
+      widget.setAttribute("challengeurl", challengeUrl);
+      if (auto) {
+        widget.setAttribute("auto", "onload");
+      }
+      if (hidelogo) {
+        widget.setAttribute("hidelogo", "true");
+      }
+      widget.setAttribute("hidefooter", "true");
+      if (className) {
+        widget.className = className;
+      }
+      widget.addEventListener("statechange", ((event) => {
+        const { state, payload } = event.detail;
+        if (state === "verified" && payload) {
+          onSolutionChange?.(payload);
+        } else if (state === "error" || state === "expired") {
+          onSolutionChange?.(null);
+        }
+      }));
+      containerRef.current.appendChild(widget);
+      setIsLoaded(true);
+    }).catch((err) => {
+      console.error("Failed to load ALTCHA widget:", err);
+    });
+    return () => {
+      if (widget && containerRef.current) {
+        containerRef.current.removeChild(widget);
+      }
+    };
+  }, [challengeUrl, auto, hidelogo, className, onSolutionChange]);
+  return /* @__PURE__ */ jsx("div", { ref: containerRef });
+}
+
+// ../altcha/src/client.ts
+function isSpamProtectionEnabled() {
+  return process.env.NEXT_PUBLIC_SPAM_PROTECTION_ENABLED === "true";
+}
+
+// ../../node_modules/.pnpm/altcha-lib@1.4.1/node_modules/altcha-lib/dist/helpers.js
+new TextEncoder();
+
+// ../altcha/src/index.ts
+function getCmsApiUrl() {
+  const env = process.env.RIVERBANK_ENV;
+  if (env) {
+    const envKey = `RIVERBANK_${env.toUpperCase()}_DASHBOARD_URL`;
+    const dashboardUrl2 = process.env[envKey];
+    if (dashboardUrl2) {
+      return `${dashboardUrl2.replace(/\/$/, "")}/api`;
+    }
+  }
+  const dashboardUrl = process.env.NEXT_PUBLIC_DASHBOARD_URL;
+  if (dashboardUrl) {
+    return `${dashboardUrl.replace(/\/$/, "")}/api`;
+  }
+  const legacyApiUrl = process.env.NEXT_PUBLIC_CMS_API_URL;
+  if (legacyApiUrl) {
+    return legacyApiUrl.replace(/\/$/, "");
+  }
+  throw new Error("Dashboard URL not configured. Set NEXT_PUBLIC_DASHBOARD_URL");
+}
+function getChallengeUrl() {
+  return `${getCmsApiUrl()}/public/challenge`;
+}
+
+export { AltchaWidget, getChallengeUrl, isSpamProtectionEnabled };

package/dist/client/chunk-ZLMS67RR.mjs

@@ -0,0 +1,106 @@
+import { EMPTY_COMMERCE_CART_STATE, parseStoredCommerceCartState, reduceCommerceCart, buildPassCartItem } from './chunk-FU2QRZMX.mjs';
+import * as React from 'react';
+
+var EMPTY_STATE = EMPTY_COMMERCE_CART_STATE;
+var stores = /* @__PURE__ */ new Map();
+function storageKey(siteId) {
+  return `riverbank:shop-cart:${siteId}`;
+}
+var CommerceCartStore = class {
+  constructor(siteId) {
+    this.siteId = siteId;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.state = typeof window === "undefined" ? EMPTY_STATE : parseStoredCommerceCartState(window.localStorage.getItem(storageKey(siteId)));
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getSnapshot() {
+    return this.state;
+  }
+  addProduct(input) {
+    this.setState(
+      reduceCommerceCart(this.state, {
+        type: "add_product",
+        item: {
+          key: input.key,
+          kind: "product",
+          productId: input.productId,
+          ...input.variantId ? { variantId: input.variantId } : {},
+          title: input.title,
+          variantTitle: input.variantTitle ?? null,
+          quantity: input.quantity ?? 1,
+          unitPriceCents: input.unitPriceCents,
+          currency: input.currency,
+          imageUrl: input.imageUrl ?? null,
+          soldOut: input.soldOut ?? false
+        }
+      })
+    );
+  }
+  addPass(input) {
+    this.setState(
+      reduceCommerceCart(this.state, {
+        type: "add_pass",
+        item: buildPassCartItem(input)
+      })
+    );
+  }
+  updateQuantity(itemKey, quantity) {
+    this.setState(reduceCommerceCart(this.state, {
+      type: "update_quantity",
+      itemKey,
+      quantity
+    }));
+  }
+  removeItem(itemKey) {
+    this.setState(reduceCommerceCart(this.state, {
+      type: "remove_item",
+      itemKey
+    }));
+  }
+  clear() {
+    this.setState(reduceCommerceCart(this.state, { type: "clear" }));
+  }
+  setState(nextState) {
+    this.state = nextState;
+    if (typeof window !== "undefined") {
+      window.localStorage.setItem(storageKey(this.siteId), JSON.stringify(nextState));
+    }
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+};
+function getStore(siteId) {
+  const existing = stores.get(siteId);
+  if (existing) return existing;
+  const next = new CommerceCartStore(siteId);
+  stores.set(siteId, next);
+  return next;
+}
+function addPassToCommerceCart(siteId, input) {
+  getStore(siteId ?? "unknown").addPass(input);
+}
+function useCommerceCart(siteId) {
+  const effectiveSiteId = siteId ?? "unknown";
+  const store = React.useMemo(() => getStore(effectiveSiteId), [effectiveSiteId]);
+  const state = React.useSyncExternalStore(
+    (listener) => store.subscribe(listener),
+    () => store.getSnapshot(),
+    () => EMPTY_STATE
+  );
+  return {
+    items: state.items,
+    addProduct: store.addProduct.bind(store),
+    addPass: store.addPass.bind(store),
+    updateQuantity: store.updateQuantity.bind(store),
+    removeItem: store.removeItem.bind(store),
+    clear: store.clear.bind(store)
+  };
+}
+
+export { addPassToCommerceCart, useCommerceCart };