@juo/blocks 1.0.0

package/dist/core.js

@@ -0,0 +1,1163 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { c as createContext, d, w, E, u } from "./theme-state-BZplRS92.js";
+import { B, n, C, D, S, T, a, b, e, f, k, l, g, h, i, m, p, o, q, r, s, t, v, j } from "./theme-state-BZplRS92.js";
+import { T as T2, W, c, b as b2, a as a2, g as g2, h as h2 } from "./juo-workflow-RSrOuKUH.js";
+function createState() {
+  const discountCode = d(null);
+  const products = d([]);
+  const subscriptions = d([]);
+  const user = d({
+    name: "John Doe"
+  });
+  const upcomingOrder = w(() => {
+    if (subscriptions.value.length === 0) {
+      return null;
+    }
+    const subscription = subscriptions.value[0];
+    const subtotal = Math.round(
+      100 * subscription.items.reduce(
+        (acc, item) => acc + item.price * item.quantity,
+        0
+      )
+    ) / 100;
+    const deliveryPrice = subtotal >= 80 ? 0 : 4.9;
+    const discount = discountCode.value ? 0.2 : 0;
+    const totalDiscount = Math.round(100 * subtotal * discount) / 100;
+    return {
+      ...subscription,
+      subtotal,
+      totalDiscount,
+      deliveryPrice,
+      totalPrice: Math.round(100 * (subtotal - totalDiscount + deliveryPrice)) / 100,
+      hasFreeProduct: subscription.items.some(({ price }) => price == 0)
+    };
+  });
+  return {
+    discountCode,
+    products,
+    upcomingOrder,
+    subscriptions,
+    user,
+    setDiscountCode(code) {
+      discountCode.value = code;
+    },
+    addProduct(product) {
+      products.value = [...products.value, product];
+    },
+    getProductById(id) {
+      const product = products.value.find((product2) => product2.id === id);
+      if (product == null) {
+        throw new Error("Product not found");
+      }
+      return product;
+    },
+    addItemToUpcomingOrder(item) {
+      const product = this.getProductById(item.productId);
+      subscriptions.value = [
+        {
+          ...subscriptions.value[0],
+          items: [
+            ...subscriptions.value[0].items,
+            { ...item, price: product.price }
+          ]
+        },
+        ...subscriptions.value.slice(1)
+      ];
+    },
+    addSubscription(subscription) {
+      subscriptions.value = [...subscriptions.value, subscription];
+    }
+  };
+}
+const StateContext = createContext("state");
+const PARAMS = {
+  DELETGATED_TOKEN: "delegated-token",
+  REDIRECT_TO: "redirect-to",
+  ACTION: "action",
+  MISSING: "missing",
+  CODE: "code",
+  ERROR: "error",
+  STATE: "state",
+  REFRESH: "refresh"
+};
+function uuid() {
+  return ("10000000-1000-4000-8000" + -1e11).replace(
+    /[018]/g,
+    (c2) => (c2 ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c2 / 4).toString(16)
+  );
+}
+var AuthenticationErrorReason = /* @__PURE__ */ ((AuthenticationErrorReason2) => {
+  AuthenticationErrorReason2["Expired"] = "expired";
+  AuthenticationErrorReason2["IncorrectCode"] = "wrong-code";
+  AuthenticationErrorReason2["TooManyTries"] = "too-many-tries";
+  AuthenticationErrorReason2["NoEmail"] = "no-email";
+  AuthenticationErrorReason2["Unknown"] = "unknown";
+  AuthenticationErrorReason2["Missing"] = "missing";
+  return AuthenticationErrorReason2;
+})(AuthenticationErrorReason || {});
+class AuthenticationError extends Error {
+  constructor(reason, data) {
+    super("Authentication error");
+    __publicField(this, "reason");
+    __publicField(this, "data");
+    this.reason = reason;
+    this.data = data ?? {};
+  }
+}
+function storage(key, value) {
+  const storageKey = `auth:${key}`;
+  try {
+    if (value === null) {
+      sessionStorage.removeItem(storageKey);
+    } else if (value !== void 0) {
+      sessionStorage.setItem(storageKey, value);
+    } else {
+      return sessionStorage.getItem("auth:" + key);
+    }
+  } catch (error) {
+    console.warn(`Failed to use session storage: ${error}`);
+  }
+  return null;
+}
+const STORAGE_DELEGATED_TOKEN = "delegated-token";
+const STORAGE_REFRESH_TOKEN_KEY = "refresh-token";
+const STORAGE_STATE_KEY = "state";
+function createAuthFunctions(basePath, shop) {
+  async function start(email, lang) {
+    const response = await fetch(
+      `${basePath}/auth/customer/passwordless/start?lang=${lang}`,
+      {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          "X-Shopify-Shop-Domain": shop
+        },
+        body: JSON.stringify({ email })
+      }
+    );
+    if (response.status !== 200) {
+      throw new Error(`Unexpected response: ${response.statusText}`);
+    }
+  }
+  async function authenticate(data) {
+    const response = await fetch(`${basePath}/auth/customer/token`, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "X-Shopify-Shop-Domain": shop
+      },
+      body: JSON.stringify(data)
+    });
+    if (response.status === 403) {
+      const data2 = await response.json();
+      if ("error_description" in data2) {
+        if (data2.error_description === "Wrong email or verification code.") {
+          throw new AuthenticationError(
+            "wrong-code"
+            /* IncorrectCode */
+          );
+        } else if (data2.error_description === "You've reached the maximum number of attempts. Please try to login again.") {
+          throw new AuthenticationError(
+            "too-many-tries"
+            /* TooManyTries */
+          );
+        } else if (data2.error_description === "The verification code has expired. Please try to login again.") {
+          throw new AuthenticationError(
+            "expired"
+            /* Expired */
+          );
+        }
+      } else if ("code" in data2) {
+        if (data2.code === "AUTH_ERROR") {
+          throw new AuthenticationError("no-email", {
+            connection: data2.connection
+          });
+        }
+      }
+    }
+    if (response.status !== 200) {
+      throw new Error(`Unexpected response: ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  return { start, authenticate };
+}
+function nonce(len = 10) {
+  return uuid().replace(/-/g, "").slice(0, len);
+}
+function createAuthService(apiUrl, shopDomain) {
+  const { start: authStart, authenticate: authAuthenticate } = createAuthFunctions(apiUrl, shopDomain);
+  const accessToken = d(null);
+  const delegatedToken = d(
+    storage(STORAGE_DELEGATED_TOKEN)
+  );
+  const refreshToken = d(
+    storage(STORAGE_REFRESH_TOKEN_KEY)
+  );
+  const expires = d(null);
+  const state = d(storage(STORAGE_STATE_KEY));
+  E(() => {
+    storage(STORAGE_DELEGATED_TOKEN, delegatedToken.value);
+  });
+  E(() => {
+    storage(STORAGE_REFRESH_TOKEN_KEY, refreshToken.value);
+  });
+  E(() => {
+    storage(STORAGE_STATE_KEY, state.value);
+  });
+  function store(data) {
+    const { access_token, refresh_token, expires_in } = data;
+    accessToken.value = access_token;
+    refreshToken.value = refresh_token;
+    expires.value = new Date(Date.now() + expires_in);
+  }
+  return {
+    state,
+    async start(email, lang) {
+      await authStart(email, lang);
+    },
+    async authenticate(data) {
+      store(await authAuthenticate(data));
+    },
+    getDelegatedToken() {
+      return delegatedToken.value;
+    },
+    setDelegatedToken(token) {
+      delegatedToken.value = token;
+    },
+    async getToken() {
+      if (refreshToken.value == null) {
+        return null;
+      }
+      if (accessToken.value == null || typeof accessToken.value === "string" && (expires.value == null || expires.value < /* @__PURE__ */ new Date())) {
+        accessToken.value = new Promise(
+          (resolve, reject) => authAuthenticate({ refreshToken: refreshToken.value }).then((data) => data).then((data) => {
+            store(data);
+            resolve(data.access_token);
+            return;
+          }).catch(reject)
+        );
+      }
+      return Promise.resolve(accessToken.value);
+    },
+    logout() {
+      accessToken.value = null;
+      delegatedToken.value = null;
+      refreshToken.value = null;
+      expires.value = null;
+    },
+    isAuthenticated: w(
+      () => delegatedToken.value != null || refreshToken.value != null
+    )
+  };
+}
+function loginService(deps) {
+  return createLoginService({
+    apiUrl: `${deps.shop.rootUrl.replace(/\/$/, "")}/api`,
+    router: deps.router,
+    formatError: deps.formatError,
+    shop: {
+      domain: deps.shop.domain,
+      locale: w(() => deps.getLocale())
+    },
+    onLoginSuccess: deps.onLoginSuccess
+  });
+}
+function createLoginService(init) {
+  const { formatError, router, shop, onLoginSuccess } = init;
+  const auth = createAuthService(init.apiUrl.replace(/\/$/, ""), shop.domain);
+  const userEmail = d(null);
+  async function onSuccess(query) {
+    await (onLoginSuccess == null ? void 0 : onLoginSuccess());
+    if (query && query.has(PARAMS.REDIRECT_TO)) {
+      if (query.has(PARAMS.ACTION)) {
+        const redirect = query.get(PARAMS.REDIRECT_TO);
+        const queryParams = {};
+        query.forEach((value, key) => {
+          if (key !== PARAMS.DELETGATED_TOKEN && key !== PARAMS.REDIRECT_TO) {
+            queryParams[key] = value;
+          }
+        });
+        router.push({
+          path: decodeURIComponent(redirect),
+          query: queryParams
+        });
+      } else {
+        const redirect = query.get(PARAMS.REDIRECT_TO);
+        router.replace(decodeURIComponent(redirect));
+      }
+    } else {
+      router.replace("/");
+    }
+  }
+  const service = {
+    passwordless: {
+      email: {
+        async start(email) {
+          try {
+            userEmail.value = email;
+            await auth.start(
+              userEmail.value,
+              shop.locale instanceof u ? shop.locale.value : shop.locale
+            );
+            return { _tag: "Success", data: void 0 };
+          } catch (error) {
+            return {
+              _tag: "Failure",
+              error: formatError(error)
+            };
+          }
+        },
+        async verify(email, code) {
+          if (email !== userEmail.value) {
+            return {
+              _tag: "Failure",
+              error: formatError("User email mismatch")
+            };
+          }
+          try {
+            const result = await auth.authenticate({
+              email: userEmail.value,
+              code
+            });
+            await onSuccess();
+            return { _tag: "Success", data: result };
+          } catch (error) {
+            return {
+              _tag: "Failure",
+              error: formatError(error)
+            };
+          }
+        }
+      }
+    },
+    social: {
+      async start(provider) {
+        function socialUrl(key, shop2) {
+          auth.state.value = nonce();
+          const url = new URL(
+            // TODO: double check admin url
+            `${"https://admin.juo.io"}/auth/customer/authorize`
+          );
+          url.searchParams.append("connection", key);
+          url.searchParams.append("state", auth.state.value ?? "");
+          url.searchParams.append("shop", shop2);
+          return url.toString();
+        }
+        window.location.href = socialUrl(
+          provider === "Facebook" ? "facebook" : "google-oauth2",
+          shop.domain
+        );
+        return {
+          _tag: "Success",
+          data: void 0
+        };
+      },
+      async verify(code) {
+        try {
+          const result = await auth.authenticate({ code });
+          await onSuccess();
+          return { _tag: "Success", data: result };
+        } catch (error) {
+          return {
+            _tag: "Failure",
+            error: formatError(error)
+          };
+        }
+      }
+    },
+    async logout() {
+      await auth.logout();
+      return { _tag: "Success", data: void 0 };
+    },
+    async handleQueryParams(query) {
+      if (query.has(PARAMS.DELETGATED_TOKEN)) {
+        auth.setDelegatedToken(query.get(PARAMS.DELETGATED_TOKEN));
+        await onSuccess(query);
+        return { _tag: "Success", data: void 0 };
+      }
+      if (query.has(PARAMS.ERROR)) {
+        return {
+          _tag: "Failure",
+          error: formatError(query.get(PARAMS.ERROR))
+        };
+      }
+      const code = query.get(PARAMS.CODE);
+      if (code != null) {
+        if (query.get(PARAMS.STATE) !== auth.state.value) {
+          return {
+            _tag: "Failure",
+            error: formatError("Invalid state")
+          };
+        } else {
+          return service.social.verify(code);
+        }
+      }
+      if (query.get(PARAMS.REFRESH) === "1" && await auth.getToken() != null) {
+        await onSuccess();
+        return { _tag: "Success", data: void 0 };
+      }
+      if (query.get(PARAMS.MISSING) === "1") {
+        return {
+          _tag: "Failure",
+          error: formatError(
+            new AuthenticationError(
+              "missing"
+              /* Missing */
+            )
+          )
+        };
+      }
+      return { _tag: "Success", data: void 0 };
+    },
+    isAuthenticated: auth.isAuthenticated,
+    getToken: () => auth.getToken()
+  };
+  return service;
+}
+const LoginServiceContext = createContext("services/login");
+function createMockProductAdapter() {
+  const products = [
+    {
+      id: "sample-1",
+      title: "Hydrating Gel Cleanser for Face and Eye Area",
+      featuredImage: {
+        url: "https://via.placeholder.com/400x400?text=Product+1"
+      },
+      hasOnlyDefaultVariant: true,
+      variants: [
+        {
+          id: "sample-1-1",
+          title: "150 ml bottle",
+          image: {
+            url: "https://via.placeholder.com/400x400?text=Product+1"
+          },
+          price: {
+            amount: "12.49",
+            currencyCode: "EUR"
+          }
+        }
+      ],
+      collections: []
+    },
+    {
+      id: "sample-2",
+      title: "More COLLAGEN",
+      featuredImage: {
+        url: "https://via.placeholder.com/400x400?text=Product+2"
+      },
+      hasOnlyDefaultVariant: true,
+      variants: [
+        {
+          id: "sample-2-1",
+          title: "blackcurrant",
+          image: {
+            url: "https://via.placeholder.com/400x400?text=Product+2"
+          },
+          price: {
+            amount: "12.49",
+            currencyCode: "EUR"
+          }
+        }
+      ],
+      collections: []
+    },
+    {
+      id: "sample-3",
+      title: "Gentle deodorant for underarms and bust",
+      featuredImage: {
+        url: "https://via.placeholder.com/400x400?text=Product+3"
+      },
+      hasOnlyDefaultVariant: true,
+      variants: [
+        {
+          id: "sample-3-1",
+          title: "Green tea and jasmine",
+          image: {
+            url: "https://via.placeholder.com/400x400?text=Product+3"
+          },
+          price: {
+            amount: "6.7",
+            currencyCode: "EUR"
+          }
+        }
+      ],
+      collections: []
+    }
+  ];
+  function processProduct(product) {
+    return {
+      ...product,
+      variants: {
+        items: product.variants,
+        pageInfo: {
+          hasNextPage: false,
+          hasPrevPage: false,
+          startCursor: null,
+          endCursor: null
+        }
+      }
+    };
+  }
+  return {
+    async getById(id) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      const product = products.find((product2) => product2.id === id);
+      return product == null ? null : processProduct(product);
+    },
+    async getByVariantId(variantId) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      const product = products.find(
+        (product2) => product2.variants.some((variant) => variant.id === variantId)
+      );
+      return product == null ? null : processProduct(product);
+    },
+    async search(opts) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      let filteredProducts = [...products];
+      if (opts == null ? void 0 : opts.query) {
+        const queryLower = opts.query.toLowerCase();
+        filteredProducts = filteredProducts.filter(
+          (product) => product.title.toLowerCase().includes(queryLower) || product.variants.some(
+            (variant) => variant.title.toLowerCase().includes(queryLower)
+          )
+        );
+      }
+      let startIndex = 0;
+      let endIndex = filteredProducts.length;
+      const pageSize = 10;
+      if (opts == null ? void 0 : opts.pagination) {
+        if ("after" in opts.pagination) {
+          const cursorIndex = parseInt(opts.pagination.after, 10);
+          startIndex = cursorIndex + 1;
+          endIndex = Math.min(startIndex + pageSize, filteredProducts.length);
+        } else if ("before" in opts.pagination) {
+          const cursorIndex = parseInt(opts.pagination.before, 10);
+          endIndex = cursorIndex;
+          startIndex = Math.max(0, endIndex - pageSize);
+        }
+      } else {
+        endIndex = Math.min(pageSize, filteredProducts.length);
+      }
+      const pageItems = filteredProducts.slice(startIndex, endIndex);
+      return {
+        items: pageItems.map(processProduct),
+        pageInfo: {
+          hasNextPage: endIndex < filteredProducts.length,
+          hasPrevPage: startIndex > 0,
+          startCursor: pageItems.length > 0 ? startIndex.toString() : null,
+          endCursor: pageItems.length > 0 ? (endIndex - 1).toString() : null
+        }
+      };
+    }
+  };
+}
+const ProductServiceContext = createContext("services/product");
+function createProductService(adapter) {
+  return {
+    async getById(id) {
+      return adapter.getById(id);
+    },
+    async getByVariantId(variantId) {
+      return adapter.getByVariantId(variantId);
+    },
+    async search(opts) {
+      return adapter.search(opts);
+    }
+  };
+}
+function createMockSubscriptionAdapter() {
+  const mockSubscriptions = [
+    {
+      id: "sub_1",
+      customerId: "customer_1",
+      items: [
+        {
+          id: "item_1",
+          productId: "product_1",
+          variantId: "variant_1",
+          quantity: 2,
+          price: { amount: "29.99", currencyCode: "USD" },
+          nextDeliveryDate: /* @__PURE__ */ new Date("2025-11-15")
+        }
+      ],
+      discounts: [
+        {
+          id: "discount_1",
+          type: "percentage",
+          value: 10,
+          code: "SAVE10",
+          description: "10% off subscription"
+        }
+      ],
+      status: "active",
+      nextDeliveryDate: /* @__PURE__ */ new Date("2025-11-15"),
+      frequency: "1 MONTH",
+      createdAt: "2024-10-01T00:00:00Z",
+      updatedAt: "2024-10-14T00:00:00Z"
+    },
+    {
+      id: "sub_2",
+      customerId: "customer_1",
+      items: [
+        {
+          id: "item_2",
+          productId: "product_2",
+          variantId: "variant_2",
+          quantity: 1,
+          price: { amount: "49.99", currencyCode: "USD" },
+          nextDeliveryDate: /* @__PURE__ */ new Date("2025-11-20")
+        }
+      ],
+      discounts: [],
+      status: "active",
+      nextDeliveryDate: /* @__PURE__ */ new Date("2025-11-20"),
+      frequency: "2 WEEK",
+      createdAt: "2024-09-15T00:00:00Z",
+      updatedAt: "2024-10-10T00:00:00Z"
+    }
+  ];
+  return {
+    async getById(id) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const subscription = mockSubscriptions.find((sub) => sub.id === id) || null;
+      return { _tag: "Success", data: subscription };
+    },
+    async search(options = {}) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const pageSize = 1;
+      const allItems = mockSubscriptions;
+      let startIndex = 0;
+      let endIndex = pageSize;
+      if (options.pagination) {
+        if ("after" in options.pagination) {
+          const cursorIndex = parseInt(options.pagination.after, 10);
+          startIndex = cursorIndex + 1;
+          endIndex = startIndex + pageSize;
+        } else if ("before" in options.pagination) {
+          const cursorIndex = parseInt(options.pagination.before, 10);
+          endIndex = cursorIndex;
+          startIndex = Math.max(0, endIndex - pageSize);
+        }
+      }
+      const pageItems = allItems.slice(startIndex, endIndex);
+      const paginatedList = {
+        items: pageItems.map((sub) => ({
+          ...sub,
+          items: sub.items.map((item) => ({ ...item })),
+          discounts: sub.discounts.map((discount) => ({ ...discount }))
+        })),
+        pageInfo: {
+          hasNextPage: endIndex < allItems.length,
+          hasPrevPage: startIndex > 0,
+          startCursor: pageItems.length > 0 ? startIndex.toString() : null,
+          endCursor: pageItems.length > 0 ? (endIndex - 1).toString() : null
+        }
+      };
+      return { _tag: "Success", data: paginatedList };
+    },
+    async addItem() {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      return { _tag: "Success", data: void 0 };
+    },
+    async removeItem() {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      return { _tag: "Success", data: void 0 };
+    },
+    async addDiscount() {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      return { _tag: "Success", data: void 0 };
+    },
+    async removeDiscount() {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      return { _tag: "Success", data: void 0 };
+    },
+    async reschedule(params) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const subscription = mockSubscriptions.find(
+        (sub) => sub.id === params.subscriptionId
+      );
+      if (!subscription) {
+        return {
+          _tag: "Failure",
+          error: "Subscription not found"
+        };
+      }
+      subscription.nextDeliveryDate = new Date(params.newDate);
+      subscription.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      subscription.items.forEach((item) => {
+        item.nextDeliveryDate = new Date(params.newDate);
+      });
+      return {
+        _tag: "Success",
+        data: {
+          ...subscription,
+          items: subscription.items.map((item) => ({ ...item })),
+          discounts: subscription.discounts.map((discount) => ({ ...discount }))
+        }
+      };
+    },
+    async resume(params) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const subscription = mockSubscriptions.find(
+        (sub) => sub.id === params.subscriptionId
+      );
+      if (!subscription) {
+        return {
+          _tag: "Failure",
+          error: "Subscription not found"
+        };
+      }
+      subscription.status = "active";
+      subscription.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        _tag: "Success",
+        data: {
+          ...subscription,
+          items: subscription.items.map((item) => ({ ...item })),
+          discounts: subscription.discounts.map((discount) => ({ ...discount }))
+        }
+      };
+    },
+    async pause(params) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const subscription = mockSubscriptions.find(
+        (sub) => sub.id === params.subscriptionId
+      );
+      if (!subscription) {
+        return {
+          _tag: "Failure",
+          error: "Subscription not found"
+        };
+      }
+      subscription.status = "paused";
+      subscription.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        _tag: "Success",
+        data: {
+          ...subscription,
+          items: subscription.items.map((item) => ({ ...item })),
+          discounts: subscription.discounts.map((discount) => ({ ...discount }))
+        }
+      };
+    },
+    async reactivate(params) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const subscription = mockSubscriptions.find(
+        (sub) => sub.id === params.subscriptionId
+      );
+      if (!subscription) {
+        return {
+          _tag: "Failure",
+          error: "Subscription not found"
+        };
+      }
+      subscription.status = "active";
+      subscription.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        _tag: "Success",
+        data: {
+          ...subscription,
+          items: subscription.items.map((item) => ({ ...item })),
+          discounts: subscription.discounts.map((discount) => ({ ...discount }))
+        }
+      };
+    },
+    async cancel(params) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const subscription = mockSubscriptions.find(
+        (sub) => sub.id === params.subscriptionId
+      );
+      if (!subscription) {
+        return {
+          _tag: "Failure",
+          error: "Subscription not found"
+        };
+      }
+      subscription.status = "canceled";
+      subscription.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        _tag: "Success",
+        data: {
+          ...subscription,
+          items: subscription.items.map((item) => ({ ...item })),
+          discounts: subscription.discounts.map((discount) => ({ ...discount }))
+        }
+      };
+    },
+    async getAvailablePlans() {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      return {
+        _tag: "Success",
+        data: [
+          {
+            id: "plan_1",
+            name: "Monthly",
+            billingPolicy: { intervalCount: 1, interval: "MONTH" },
+            deliveryPolicy: { intervalCount: 1, interval: "MONTH" }
+          },
+          {
+            id: "plan_2",
+            name: "Every 2 months",
+            billingPolicy: { intervalCount: 2, interval: "MONTH" },
+            deliveryPolicy: { intervalCount: 2, interval: "MONTH" }
+          },
+          {
+            id: "plan_3",
+            name: "Every 3 months",
+            billingPolicy: { intervalCount: 3, interval: "MONTH" },
+            deliveryPolicy: { intervalCount: 3, interval: "MONTH" }
+          }
+        ]
+      };
+    },
+    async getDefaultSubscriptionId() {
+      var _a;
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      return { _tag: "Success", data: ((_a = mockSubscriptions[0]) == null ? void 0 : _a.id) ?? null };
+    }
+  };
+}
+const SubscriptionServiceContext = createContext("services/subscription");
+function getCurrentSubscriptionId() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const pathname = window.location.pathname;
+  const segments = pathname.split("/").filter(Boolean);
+  const subscriptionIndex = segments.findIndex(
+    (segment) => segment === "subscriptions" || segment === "subscription"
+  );
+  if (subscriptionIndex !== -1 && segments[subscriptionIndex + 1]) {
+    return segments[subscriptionIndex + 1];
+  }
+  const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  const lastSegment = segments[segments.length - 1];
+  if (lastSegment && uuidPattern.test(lastSegment)) {
+    return lastSegment;
+  }
+  return null;
+}
+function createSubscriptionService(adapter) {
+  return {
+    search: adapter.search,
+    getById: adapter.getById,
+    getCurrentSubscriptionId,
+    addItem: (subscriptionId, item) => adapter.addItem({ subscriptionId, item }),
+    removeItem: (subscriptionId, itemId) => adapter.removeItem({ subscriptionId, itemId }),
+    addDiscount: (subscriptionId, code) => adapter.addDiscount({ subscriptionId, code }),
+    removeDiscount: (subscriptionId, discountId) => adapter.removeDiscount({ subscriptionId, discountId }),
+    reschedule: (subscriptionId, newDate) => adapter.reschedule({ subscriptionId, newDate }),
+    resume: (subscriptionId) => adapter.resume({ subscriptionId }),
+    pause: (subscriptionId) => adapter.pause({ subscriptionId }),
+    reactivate: (subscriptionId) => adapter.reactivate({ subscriptionId }),
+    cancel: (subscriptionId, reason) => adapter.cancel({ subscriptionId, reason }),
+    getAvailablePlans: (subscriptionId) => adapter.getAvailablePlans({ subscriptionId }),
+    getDefaultSubscriptionId: () => adapter.getDefaultSubscriptionId()
+  };
+}
+const MOCK_FLOWS = {
+  cancellation: [
+    {
+      stepId: "step-reason",
+      actionType: "poll",
+      actionConfig: { question: "Why are you cancelling?" },
+      availableResponses: [
+        { type: "too_expensive", label: "Too expensive" },
+        { type: "not_using", label: "Not using it" },
+        { type: "switching", label: "Switching to competitor" },
+        { type: "other", label: "Other reason" }
+      ]
+    },
+    {
+      stepId: "step-offer-discount",
+      actionType: "offer_discount",
+      actionConfig: {
+        headline: "We'd hate to see you go!",
+        description: "How about 20% off your next 3 months?",
+        discountType: "percentage",
+        discountValue: 20,
+        recurringCycleLimit: 3
+      },
+      availableResponses: [
+        { type: "accepted", label: "Accept offer" },
+        { type: "declined", label: "No thanks" }
+      ]
+    },
+    {
+      stepId: "step-feedback",
+      actionType: "collect_feedback",
+      actionConfig: {
+        headline: "Any final thoughts?",
+        description: "Your feedback helps us improve.",
+        placeholder: "Tell us what we could do better...",
+        submitLabel: "Submit feedback",
+        skipLabel: "Skip"
+      },
+      availableResponses: [
+        { type: "submitted", label: "Submit" },
+        { type: "skipped", label: "Skip" }
+      ]
+    },
+    {
+      stepId: "step-confirmation",
+      actionType: "show_confirmation",
+      actionConfig: {
+        headline: "Thank you!",
+        message: "Your feedback has been recorded.",
+        buttonLabel: "Done"
+      },
+      availableResponses: [
+        { type: "acknowledge", label: "Done" }
+      ]
+    }
+  ],
+  retention: [
+    {
+      stepId: "step-offer-pause",
+      actionType: "offer_pause",
+      actionConfig: {
+        headline: "Need a break?",
+        description: "Pause your subscription for up to 30 days instead of cancelling.",
+        pauseDurationDays: 30
+      },
+      availableResponses: [
+        { type: "accepted", label: "Pause subscription" },
+        { type: "declined", label: "No thanks" }
+      ]
+    },
+    {
+      stepId: "step-offer-skip",
+      actionType: "offer_skip",
+      actionConfig: {
+        headline: "Skip next delivery?",
+        description: "You can skip your next delivery and resume later."
+      },
+      availableResponses: [
+        { type: "accepted", label: "Skip next delivery" },
+        { type: "declined", label: "No thanks" }
+      ]
+    },
+    {
+      stepId: "step-done",
+      actionType: "show_confirmation",
+      actionConfig: {
+        headline: "All set!",
+        message: "We've processed your request.",
+        buttonLabel: "OK"
+      },
+      availableResponses: [
+        { type: "acknowledge", label: "OK" }
+      ]
+    }
+  ],
+  dunning: [
+    {
+      stepId: "step-payment-issue",
+      actionType: "show_content",
+      actionConfig: {
+        headline: "Payment issue",
+        body: "<p>We were unable to process your last payment. Please update your payment method to continue your subscription.</p>",
+        buttonLabel: "Update payment"
+      },
+      availableResponses: [
+        { type: "acknowledge", label: "Update payment" }
+      ]
+    }
+  ],
+  onboarding: [
+    {
+      stepId: "step-welcome",
+      actionType: "show_content",
+      actionConfig: {
+        headline: "Welcome!",
+        body: "<p>Thanks for subscribing. Here's what to expect from your subscription.</p>",
+        buttonLabel: "Got it"
+      },
+      availableResponses: [
+        { type: "acknowledge", label: "Got it" }
+      ]
+    },
+    {
+      stepId: "step-choice",
+      actionType: "choice",
+      actionConfig: {
+        headline: "How would you like to get started?",
+        description: "Choose what works best for you."
+      },
+      availableResponses: [
+        { type: "tour", label: "Take a tour" },
+        { type: "skip", label: "Skip for now" }
+      ]
+    }
+  ]
+};
+const mockRuns = /* @__PURE__ */ new Map();
+let runCounter = 0;
+function delay(ms = 300) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toStepDefinitions(steps) {
+  return steps.map((step) => ({
+    stepId: step.stepId,
+    actionType: step.actionType,
+    actionConfig: step.actionConfig,
+    availableResponses: step.availableResponses
+  }));
+}
+function createInteraction(step, runId) {
+  return {
+    interactionId: `mock-int-${runId}-${step.stepId}`,
+    stepId: step.stepId,
+    actionType: step.actionType,
+    actionBehavior: "input",
+    actionConfig: step.actionConfig,
+    availableResponses: step.availableResponses,
+    presentedAt: /* @__PURE__ */ new Date()
+  };
+}
+function createMockWorkflowApiAdapter() {
+  return {
+    async start(flowType, _context) {
+      await delay(400);
+      const steps = MOCK_FLOWS[flowType];
+      if (!steps) {
+        return { status: "no_workflow" };
+      }
+      runCounter++;
+      const runId = `mock-run-${runCounter}`;
+      const workflowId = `mock-wf-${flowType}`;
+      const run = {
+        workflowId,
+        flowType,
+        steps,
+        currentStepIndex: 0,
+        runVersion: 1
+      };
+      mockRuns.set(runId, run);
+      const step = steps[0];
+      return {
+        workflowId,
+        workflowVersion: 1,
+        runId,
+        runVersion: 1,
+        status: "waiting_interaction",
+        pendingInteraction: createInteraction(step, runId),
+        interactiveSteps: toStepDefinitions(steps)
+      };
+    },
+    async respond(runId, _interactionId, _responseType, _responseData, _expectedRunVersion) {
+      await delay(300);
+      const run = mockRuns.get(runId);
+      if (!run) {
+        throw new Error(`Mock run ${runId} not found`);
+      }
+      run.currentStepIndex++;
+      run.runVersion++;
+      if (run.currentStepIndex >= run.steps.length) {
+        mockRuns.delete(runId);
+        return {
+          workflowId: run.workflowId,
+          workflowVersion: 1,
+          runId,
+          runVersion: run.runVersion,
+          status: "completed",
+          result: { flowType: run.flowType, completedAt: (/* @__PURE__ */ new Date()).toISOString() }
+        };
+      }
+      const nextStep = run.steps[run.currentStepIndex];
+      return {
+        workflowId: run.workflowId,
+        workflowVersion: 1,
+        runId,
+        runVersion: run.runVersion,
+        status: "waiting_interaction",
+        pendingInteraction: createInteraction(nextStep, runId)
+      };
+    },
+    async getState(runId) {
+      await delay(100);
+      const run = mockRuns.get(runId);
+      if (!run) {
+        throw new Error(`Mock run ${runId} not found`);
+      }
+      const step = run.steps[run.currentStepIndex];
+      return {
+        workflowId: run.workflowId,
+        workflowVersion: 1,
+        runId,
+        runVersion: run.runVersion,
+        status: "waiting_interaction",
+        pendingInteraction: createInteraction(step, runId)
+      };
+    },
+    async cancel(runId) {
+      await delay(100);
+      const run = mockRuns.get(runId);
+      const workflowId = (run == null ? void 0 : run.workflowId) ?? "unknown";
+      mockRuns.delete(runId);
+      return {
+        workflowId,
+        workflowVersion: 1,
+        runId,
+        runVersion: ((run == null ? void 0 : run.runVersion) ?? 0) + 1,
+        status: "cancelled"
+      };
+    }
+  };
+}
+export {
+  AuthenticationError,
+  AuthenticationErrorReason,
+  B as BlockWrapperEvent,
+  n as ContextProvideEvent,
+  C as ContextRequestEvent,
+  D as DEFAULT_GLOBAL_STYLES,
+  LoginServiceContext,
+  ProductServiceContext,
+  S as SelectedBlockContext,
+  u as Signal,
+  StateContext,
+  SubscriptionServiceContext,
+  T as ThemeStateContext,
+  T2 as TranslationContext,
+  W as WorkflowServiceContext,
+  w as computed,
+  a as createBlockInstance,
+  b as createBlockInstanceFromJSON,
+  e as createBlockInstanceFromObject,
+  f as createCeRenderer,
+  createContext,
+  createMockProductAdapter,
+  createMockSubscriptionAdapter,
+  createMockWorkflowApiAdapter,
+  createProductService,
+  k as createSelectedBlock,
+  createState,
+  createSubscriptionService,
+  l as createThemeState,
+  c as createTranslationService,
+  b2 as createWorkflowApiAdapter,
+  a2 as createWorkflowService,
+  g as defineBlock,
+  h as defineBlockRuntime,
+  E as effect,
+  g2 as getDefaultBlockForAction,
+  i as getDefinedBlocks,
+  h2 as hasDefaultBlockForAction,
+  m as indexOverrides,
+  p as injectContext,
+  loginService,
+  o as onRegisterBlock,
+  q as provideContext,
+  r as registerBlock,
+  s as serializeBlocks,
+  d as signal,
+  t as subscribeContext,
+  v as untracked,
+  j as withWrapper
+};