@jay-framework/wix-stores-v1 0.15.0

package/dist/index.client.js

@@ -0,0 +1,799 @@
+import { WIX_CART_CONTEXT, cartIndicator, cartPage } from "@jay-framework/wix-cart/client";
+import { makeJayStackComponent, makeJayInit } from "@jay-framework/fullstack-component";
+import { registerReactiveGlobalContext, createSignal, createMemo, createEffect } from "@jay-framework/component";
+import { patch, REPLACE } from "@jay-framework/json-patch";
+import { createJayContext, useGlobalContext } from "@jay-framework/runtime";
+import { WIX_CLIENT_CONTEXT } from "@jay-framework/wix-server-client/client";
+import { WIX_CART_CONTEXT as WIX_CART_CONTEXT2 } from "@jay-framework/wix-cart";
+import { products, collections } from "@wix/stores";
+import { createActionCaller } from "@jay-framework/stack-client-runtime";
+var StockStatus = /* @__PURE__ */ ((StockStatus2) => {
+  StockStatus2[StockStatus2["OUT_OF_STOCK"] = 0] = "OUT_OF_STOCK";
+  StockStatus2[StockStatus2["IN_STOCK"] = 1] = "IN_STOCK";
+  return StockStatus2;
+})(StockStatus || {});
+var Selected = /* @__PURE__ */ ((Selected2) => {
+  Selected2[Selected2["selected"] = 0] = "selected";
+  Selected2[Selected2["notSelected"] = 1] = "notSelected";
+  return Selected2;
+})(Selected || {});
+const instances = {
+  productsClientInstance: void 0,
+  collectionsClientInstance: void 0
+};
+function getProductsClient(wixClient) {
+  if (!instances.productsClientInstance) {
+    instances.productsClientInstance = wixClient.use(products);
+  }
+  return instances.productsClientInstance;
+}
+function getCollectionsClient(wixClient) {
+  if (!instances.collectionsClientInstance) {
+    instances.collectionsClientInstance = wixClient.use(collections);
+  }
+  return instances.collectionsClientInstance;
+}
+var MediaType = /* @__PURE__ */ ((MediaType2) => {
+  MediaType2[MediaType2["IMAGE"] = 0] = "IMAGE";
+  MediaType2[MediaType2["VIDEO"] = 1] = "VIDEO";
+  return MediaType2;
+})(MediaType || {});
+var AvailabilityStatus = /* @__PURE__ */ ((AvailabilityStatus2) => {
+  AvailabilityStatus2[AvailabilityStatus2["IN_STOCK"] = 0] = "IN_STOCK";
+  AvailabilityStatus2[AvailabilityStatus2["OUT_OF_STOCK"] = 1] = "OUT_OF_STOCK";
+  AvailabilityStatus2[AvailabilityStatus2["PARTIALLY_OUT_OF_STOCK"] = 2] = "PARTIALLY_OUT_OF_STOCK";
+  return AvailabilityStatus2;
+})(AvailabilityStatus || {});
+var PreorderStatus = /* @__PURE__ */ ((PreorderStatus2) => {
+  PreorderStatus2[PreorderStatus2["ENABLED"] = 0] = "ENABLED";
+  PreorderStatus2[PreorderStatus2["DISABLED"] = 1] = "DISABLED";
+  PreorderStatus2[PreorderStatus2["PARTIALLY_ENABLED"] = 2] = "PARTIALLY_ENABLED";
+  return PreorderStatus2;
+})(PreorderStatus || {});
+var ProductType = /* @__PURE__ */ ((ProductType2) => {
+  ProductType2[ProductType2["PHYSICAL"] = 0] = "PHYSICAL";
+  ProductType2[ProductType2["DIGITAL"] = 1] = "DIGITAL";
+  return ProductType2;
+})(ProductType || {});
+var QuickAddType = /* @__PURE__ */ ((QuickAddType2) => {
+  QuickAddType2[QuickAddType2["SIMPLE"] = 0] = "SIMPLE";
+  QuickAddType2[QuickAddType2["SINGLE_OPTION"] = 1] = "SINGLE_OPTION";
+  QuickAddType2[QuickAddType2["NEEDS_CONFIGURATION"] = 2] = "NEEDS_CONFIGURATION";
+  return QuickAddType2;
+})(QuickAddType || {});
+var OptionRenderType = /* @__PURE__ */ ((OptionRenderType2) => {
+  OptionRenderType2[OptionRenderType2["TEXT_CHOICES"] = 0] = "TEXT_CHOICES";
+  OptionRenderType2[OptionRenderType2["COLOR_SWATCH_CHOICES"] = 1] = "COLOR_SWATCH_CHOICES";
+  return OptionRenderType2;
+})(OptionRenderType || {});
+var ChoiceType = /* @__PURE__ */ ((ChoiceType2) => {
+  ChoiceType2[ChoiceType2["CHOICE_TEXT"] = 0] = "CHOICE_TEXT";
+  ChoiceType2[ChoiceType2["ONE_COLOR"] = 1] = "ONE_COLOR";
+  return ChoiceType2;
+})(ChoiceType || {});
+function mapAvailabilityStatus(status) {
+  switch (status) {
+    case "OUT_OF_STOCK":
+      return AvailabilityStatus.OUT_OF_STOCK;
+    case "PARTIALLY_OUT_OF_STOCK":
+      return AvailabilityStatus.PARTIALLY_OUT_OF_STOCK;
+    default:
+      return AvailabilityStatus.IN_STOCK;
+  }
+}
+function mapPreorderStatus() {
+  return PreorderStatus.DISABLED;
+}
+function mapMediaType(mediaType) {
+  return mediaType === "video" ? MediaType.VIDEO : MediaType.IMAGE;
+}
+function mapProductType(productType) {
+  return productType === "digital" ? ProductType.DIGITAL : ProductType.PHYSICAL;
+}
+function hasProductDiscount(product) {
+  const price = product.price?.price || 0;
+  const discountedPrice = product.price?.discountedPrice || price;
+  return discountedPrice < price;
+}
+function getQuickAddType(product) {
+  const optionCount = product.productOptions?.length ?? 0;
+  if (optionCount > 1) {
+    return QuickAddType.NEEDS_CONFIGURATION;
+  }
+  if (optionCount === 1) {
+    return QuickAddType.SINGLE_OPTION;
+  }
+  return QuickAddType.SIMPLE;
+}
+function mapOptionRenderType(optionType) {
+  return optionType === "color" ? OptionRenderType.COLOR_SWATCH_CHOICES : OptionRenderType.TEXT_CHOICES;
+}
+function mapQuickOption(option, variants) {
+  if (!option) return null;
+  const choices = option.choices || [];
+  return {
+    _id: option.name,
+    name: option.name || "",
+    optionRenderType: mapOptionRenderType(option.optionType),
+    choices: choices.map((choice) => {
+      const variant = variants?.find((v) => Object.values(v.choices).includes(choice.value));
+      return {
+        choiceId: choice.description,
+        name: choice.value || "",
+        choiceType: option.optionType === "color" ? ChoiceType.ONE_COLOR : ChoiceType.CHOICE_TEXT,
+        colorCode: "",
+        // V1 doesn't store color code in choices
+        inStock: variant?.stock?.inStock ?? choice.inStock ?? true,
+        variantId: variant?._id || "",
+        isSelected: false
+      };
+    })
+  };
+}
+const DEFAULT_PRODUCT_PAGE_PATH = "/products";
+function mapProductToCard(product, productPagePath = DEFAULT_PRODUCT_PAGE_PATH) {
+  const mainMedia = product.media?.mainMedia;
+  const slug = product.slug || "";
+  product.price?.discountedPrice ?? product.price?.price ?? 0;
+  product.price?.price ?? 0;
+  const formattedActualPrice = product.price?.formatted?.discountedPrice || "";
+  const formattedCompareAtPrice = product.price?.formatted?.price || "";
+  const hasDiscount = hasProductDiscount(product);
+  console.log("product", product.name, product.slug);
+  return {
+    _id: product._id || "",
+    name: product.name || "",
+    slug,
+    productUrl: slug ? `${productPagePath}/${slug}` : "",
+    mainMedia: {
+      // V1 provides complete URLs
+      url: mainMedia?.image?.url || "",
+      altText: mainMedia?.title || product.name || "",
+      mediaType: mapMediaType(mainMedia?.mediaType)
+    },
+    thumbnail: {
+      // V1 provides complete thumbnail URLs
+      url: mainMedia?.thumbnail?.url || "",
+      altText: mainMedia?.title || product.name || "",
+      width: mainMedia?.thumbnail?.width || 300,
+      height: mainMedia?.thumbnail?.height || 300
+    },
+    // Simplified price fields
+    price: formattedActualPrice,
+    strikethroughPrice: hasDiscount ? formattedCompareAtPrice : "",
+    hasDiscount,
+    inventory: {
+      // V1 uses stock.inventoryStatus
+      availabilityStatus: mapAvailabilityStatus(product.stock?.inventoryStatus),
+      preorderStatus: mapPreorderStatus()
+    },
+    ribbon: {
+      _id: product.ribbon || "",
+      name: product.ribbon || ""
+    },
+    hasRibbon: !!product.ribbon,
+    brand: {
+      _id: product.brand || "",
+      name: product.brand || ""
+    },
+    productType: mapProductType(product.productType),
+    isAddingToCart: false,
+    // Quick add behavior
+    quickAddType: getQuickAddType(product),
+    quickOption: getQuickAddType(product) === QuickAddType.SINGLE_OPTION ? mapQuickOption(product.productOptions?.[0], product.variants) : null
+  };
+}
+function mapCollectionToViewState(collection) {
+  return {
+    _id: collection._id,
+    name: collection.name || "",
+    slug: collection.slug || "",
+    description: collection.description || "",
+    imageUrl: collection.media?.mainMedia?.image?.url || "",
+    productCount: collection.numberOfProducts || 0
+  };
+}
+const WIX_STORES_V1_CONTEXT = createJayContext();
+function provideWixStoresV1Context() {
+  const wixClientContext = useGlobalContext(WIX_CLIENT_CONTEXT);
+  const wixClient = wixClientContext.client;
+  const cartContext = useGlobalContext(WIX_CART_CONTEXT2);
+  const productsClient = getProductsClient(wixClient);
+  const collectionsClient = getCollectionsClient(wixClient);
+  const storesContext = registerReactiveGlobalContext(WIX_STORES_V1_CONTEXT, () => {
+    async function addToCart(productId, quantity = 1, variantId) {
+      console.log(`[WixStoresV1] Adding to cart: ${productId} x ${quantity}`);
+      let finalVariantId = variantId;
+      let productSlug;
+      try {
+        const productResult = await productsClient.getProduct(productId);
+        const product = productResult.product;
+        productSlug = product?.slug;
+        if (!finalVariantId && product?.variants?.[0]) {
+          finalVariantId = product.variants[0]._id;
+        }
+      } catch (err) {
+        console.warn("[WixStoresV1] Could not fetch product:", err);
+      }
+      return cartContext.addToCart(productId, quantity, {
+        variantId: finalVariantId,
+        productSlug
+      });
+    }
+    async function loadMoreCollectionProducts(collectionId, page, pageSize) {
+      try {
+        const result = await productsClient.queryProducts().hasSome("collectionIds", [collectionId]).skip((page - 1) * pageSize).limit(pageSize).find();
+        const products2 = (result.items || []).map((p) => mapProductToCard(p));
+        const totalProducts = result.totalCount ?? products2.length;
+        const hasMore = page * pageSize < totalProducts;
+        return { products: products2, hasMore, totalProducts };
+      } catch (error) {
+        console.error("[WixStoresV1] Failed to load collection products:", error);
+        return { products: [], hasMore: false, totalProducts: 0 };
+      }
+    }
+    async function getCollections() {
+      try {
+        const result = await collectionsClient.queryCollections().find();
+        return (result.items || []).map((col) => mapCollectionToViewState(col));
+      } catch (error) {
+        console.error("[WixStoresV1] Failed to load collections:", error);
+        return [];
+      }
+    }
+    return {
+      // Delegate cart indicator and operations to WIX_CART_CONTEXT
+      cartIndicator: cartContext.cartIndicator,
+      refreshCartIndicator: () => cartContext.refreshCartIndicator(),
+      getEstimatedCart: () => cartContext.getEstimatedCart(),
+      addToCart,
+      // Custom implementation that resolves V1 variants first
+      removeLineItems: (ids) => cartContext.removeLineItems(ids),
+      updateLineItemQuantity: (id, qty) => cartContext.updateLineItemQuantity(id, qty),
+      clearCart: () => cartContext.clearCart(),
+      applyCoupon: (code) => cartContext.applyCoupon(code),
+      removeCoupon: () => cartContext.removeCoupon(),
+      // V1-specific operations
+      loadMoreCollectionProducts,
+      getCollections
+    };
+  });
+  console.log("[wix-stores-v1] Client stores context initialized (delegating cart to wix-cart)");
+  return storesContext;
+}
+function ProductPageInteractive(props, refs, viewStateSignals, fastCarryForward, storesContext) {
+  const [quantity, setQuantity] = createSignal(viewStateSignals.quantity[0]().quantity);
+  const { productId, variants } = fastCarryForward;
+  const { actionsEnabled: [actionsEnabled, setActionsEnabled], options: [options, setOptions], mediaGallery: [mediaGallery, setMediaGallery], pricePerUnit: [pricePerUnit, setPricePerUnit] } = viewStateSignals;
+  const [isAddingToCart, setIsAddingToCart] = createSignal(false);
+  const [selectedMediaId, setSelectedMediaId] = createSignal(null);
+  const selectedOptionsRecord = createMemo(() => {
+    const result = {};
+    for (const option of options()) {
+      if (option.textChoiceSelection) {
+        result[option._id] = option.textChoiceSelection;
+      } else {
+        const selectedChoice = option.choices.find((c) => c.isSelected);
+        if (selectedChoice) {
+          result[option._id] = selectedChoice.choiceId;
+        }
+      }
+    }
+    return result;
+  });
+  function findVariant(variants2, selectedOptions) {
+    const found = variants2.find((variant) => Object.entries(selectedOptions).every(([optionName, choiceValue]) => variant.choices[optionName] === choiceValue));
+    return found || variants2[0];
+  }
+  const selectedVariant = createMemo(() => findVariant(variants, selectedOptionsRecord()));
+  const sku = createMemo(() => selectedVariant()?.sku || "");
+  const price = createMemo(() => selectedVariant()?.price || "");
+  const strikethroughPrice = createMemo(() => selectedVariant()?.strikethroughPrice || "");
+  const stockStatus = createMemo(() => selectedVariant()?.inventoryStatus || StockStatus.OUT_OF_STOCK);
+  const computedActionsEnabled = createMemo(() => stockStatus() === StockStatus.IN_STOCK);
+  const interactiveMedia = createMemo((prev) => {
+    prev = prev || mediaGallery();
+    const oldSelectedIndex = prev.availableMedia.findIndex((_) => _.selected === Selected.selected);
+    const newSelectedIndex = Math.max(0, prev.availableMedia.findIndex((_) => _.mediaId === selectedMediaId()));
+    if (oldSelectedIndex === newSelectedIndex)
+      return prev;
+    const newSelectedMedia = prev.availableMedia[newSelectedIndex];
+    return patch(prev, [
+      { op: REPLACE, path: ["selectedMedia"], value: newSelectedMedia.media },
+      {
+        op: REPLACE,
+        path: ["availableMedia", oldSelectedIndex, "selected"],
+        value: Selected.notSelected
+      },
+      {
+        op: REPLACE,
+        path: ["availableMedia", newSelectedIndex, "selected"],
+        value: Selected.selected
+      }
+    ]);
+  });
+  refs.quantity.decrementButton.onclick(() => {
+    setQuantity((prev) => Math.max(1, prev - 1));
+  });
+  refs.quantity.incrementButton.onclick(() => {
+    setQuantity((prev) => prev + 1);
+  });
+  refs.quantity.quantity.oninput(({ event }) => {
+    const value = parseInt(event.target.value, 10);
+    if (!isNaN(value) && value > 0) {
+      setQuantity(value);
+    }
+  });
+  refs.mediaGallery?.availableMedia?.selected?.onclick(({ coordinate }) => {
+    const mediaId = coordinate[0];
+    setSelectedMediaId(mediaId);
+  });
+  refs.options?.choices?.choiceButton?.onclick(({ coordinate }) => {
+    const [optionId, choiceId] = coordinate;
+    const optionIndex = options().findIndex((_) => _._id === optionId);
+    const option = options()[optionIndex];
+    const newChoiceIndex = option.choices.findIndex((_) => _.choiceId === choiceId);
+    const oldChoiceIndex = option.choices.findIndex((_) => _.isSelected);
+    const removeSelectedPatch = oldChoiceIndex > -1 && oldChoiceIndex !== newChoiceIndex ? [
+      {
+        op: REPLACE,
+        path: [optionIndex, "choices", oldChoiceIndex, "isSelected"],
+        value: false
+      }
+    ] : [];
+    setOptions(patch(options(), [
+      {
+        op: REPLACE,
+        path: [optionIndex, "choices", newChoiceIndex, "isSelected"],
+        value: true
+      },
+      ...removeSelectedPatch
+    ]));
+  });
+  refs.options?.textChoice?.oninput(({ event, coordinate }) => {
+    const [optionId] = coordinate;
+    const optionIndex = options().findIndex((_) => _._id === optionId);
+    const selectedChoiceId = event.target.value;
+    setOptions(patch(options(), [
+      {
+        op: REPLACE,
+        path: [optionIndex, "textChoiceSelection"],
+        value: selectedChoiceId
+      }
+    ]));
+  });
+  refs.addToCartButton.onclick(async () => {
+    if (stockStatus() === StockStatus.OUT_OF_STOCK) {
+      console.warn("[ProductPage V1] Product is out of stock");
+      return;
+    }
+    setIsAddingToCart(true);
+    try {
+      const variantId = selectedVariant()?._id;
+      await storesContext.addToCart(productId, quantity(), variantId);
+      console.log("[ProductPage V1] Added to cart:", quantity(), "items");
+    } catch (error) {
+      console.error("[ProductPage V1] Failed to add to cart:", error);
+    } finally {
+      setIsAddingToCart(false);
+    }
+  });
+  return {
+    render: () => ({
+      quantity: { quantity: quantity() },
+      actionsEnabled: computedActionsEnabled,
+      options,
+      modifiers: () => [],
+      mediaGallery: interactiveMedia,
+      sku,
+      price,
+      pricePerUnit,
+      stockStatus,
+      strikethroughPrice
+    })
+  };
+}
+const productPage = makeJayStackComponent().withProps().withContexts(WIX_STORES_V1_CONTEXT).withInteractive(ProductPageInteractive);
+var CurrentSort = /* @__PURE__ */ ((CurrentSort2) => {
+  CurrentSort2[CurrentSort2["relevance"] = 0] = "relevance";
+  CurrentSort2[CurrentSort2["priceAsc"] = 1] = "priceAsc";
+  CurrentSort2[CurrentSort2["priceDesc"] = 2] = "priceDesc";
+  CurrentSort2[CurrentSort2["newest"] = 3] = "newest";
+  CurrentSort2[CurrentSort2["nameAsc"] = 4] = "nameAsc";
+  CurrentSort2[CurrentSort2["nameDesc"] = 5] = "nameDesc";
+  return CurrentSort2;
+})(CurrentSort || {});
+const searchProducts = createActionCaller("wixStoresV1.searchProducts", "GET");
+createActionCaller("wixStoresV1.getProductBySlug", "GET");
+createActionCaller("wixStoresV1.getCollections", "GET");
+const PAGE_SIZE$1 = 12;
+function ProductSearchInteractive(props, refs, viewStateSignals, fastCarryForward, storesContext) {
+  const { searchExpression: [searchExpression, setSearchExpression], isSearching: [isSearching, setIsSearching], hasSearched: [hasSearched, setHasSearched], searchResults: [searchResults, setSearchResults], resultCount: [resultCount, setResultCount], hasResults: [hasResults, setHasResults], hasSuggestions: [hasSuggestions, setHasSuggestions], suggestions: [suggestions, setSuggestions], filters: [filters, setFilters], sortBy: [sortBy, setSortBy], hasMore: [hasMore, setHasMore], loadedCount: [loadedCount, setLoadedCount], totalCount: [totalCount, setTotalCount] } = viewStateSignals;
+  const [submittedSearchTerm, setSubmittedSearchTerm] = createSignal(null);
+  const [currentPage, setCurrentPage] = createSignal(1);
+  let isFirst = true;
+  let debounceTimeout = null;
+  let searchVersion = 0;
+  const DEBOUNCE_MS = 300;
+  const mapSortToAction = (sort) => {
+    switch (sort) {
+      case CurrentSort.priceAsc:
+        return "price_asc";
+      case CurrentSort.priceDesc:
+        return "price_desc";
+      case CurrentSort.newest:
+        return "newest";
+      case CurrentSort.nameAsc:
+        return "name_asc";
+      case CurrentSort.nameDesc:
+        return "name_desc";
+      default:
+        return "relevance";
+    }
+  };
+  const performSearch = async (version, searchTerm, currentFilters, currentSort) => {
+    setIsSearching(true);
+    setHasSearched(true);
+    try {
+      const result = await searchProducts({
+        query: searchTerm || "",
+        filters: {
+          minPrice: currentFilters.priceRange.minPrice || void 0,
+          maxPrice: currentFilters.priceRange.maxPrice || void 0,
+          collectionIds: currentFilters.categoryFilter.categories.filter((c) => c.isSelected).map((c) => c.categoryId)
+        },
+        sortBy: mapSortToAction(currentSort),
+        pageSize: PAGE_SIZE$1,
+        page: 1
+      });
+      if (version !== searchVersion)
+        return;
+      setSearchResults(result.products);
+      setResultCount(result.products.length);
+      setTotalCount(result.totalCount);
+      setLoadedCount(result.products.length);
+      setHasMore(result.hasMore);
+      setHasResults(result.products.length > 0);
+      setCurrentPage(1);
+    } catch (error) {
+      if (version === searchVersion) {
+        console.error("[ProductSearch V1] Search failed:", error);
+      }
+    } finally {
+      if (version === searchVersion) {
+        setIsSearching(false);
+      }
+    }
+  };
+  const performLoadMore = async () => {
+    if (isSearching() || !hasMore())
+      return;
+    setIsSearching(true);
+    try {
+      const currentFilters = filters();
+      const currentSort = sortBy().currentSort;
+      const searchTerm = submittedSearchTerm();
+      const nextPage = currentPage() + 1;
+      const result = await searchProducts({
+        query: searchTerm || "",
+        filters: {
+          minPrice: currentFilters.priceRange.minPrice || void 0,
+          maxPrice: currentFilters.priceRange.maxPrice || void 0,
+          collectionIds: currentFilters.categoryFilter.categories.filter((c) => c.isSelected).map((c) => c.categoryId)
+        },
+        sortBy: mapSortToAction(currentSort),
+        page: nextPage,
+        pageSize: PAGE_SIZE$1
+      });
+      const currentResults = searchResults();
+      const newResults = [...currentResults, ...result.products];
+      setSearchResults(newResults);
+      setResultCount(newResults.length);
+      setLoadedCount(newResults.length);
+      setHasMore(result.hasMore);
+      setCurrentPage(nextPage);
+    } catch (error) {
+      console.error("[ProductSearch V1] Load more failed:", error);
+    } finally {
+      setIsSearching(false);
+    }
+  };
+  createEffect(() => {
+    const searchTerm = submittedSearchTerm();
+    const currentFilters = filters();
+    const currentSort = sortBy().currentSort;
+    if (isFirst) {
+      isFirst = false;
+      return;
+    }
+    if (debounceTimeout) {
+      clearTimeout(debounceTimeout);
+    }
+    debounceTimeout = setTimeout(() => {
+      searchVersion++;
+      const version = searchVersion;
+      performSearch(version, searchTerm, currentFilters, currentSort);
+    }, DEBOUNCE_MS);
+  });
+  refs.searchExpression.oninput(({ event }) => {
+    const value = event.target.value;
+    setSearchExpression(value);
+  });
+  refs.searchExpression.onkeydown(({ event }) => {
+    if (event.key === "Enter") {
+      event.preventDefault();
+      setSubmittedSearchTerm(searchExpression().trim());
+    }
+  });
+  refs.searchButton.onclick(() => {
+    setSubmittedSearchTerm(searchExpression().trim());
+  });
+  refs.clearSearchButton.onclick(() => {
+    setSearchExpression("");
+    setSubmittedSearchTerm(null);
+    setHasSearched(false);
+  });
+  refs.sortBy.sortDropdown.oninput(({ event }) => {
+    const value = event.target.value;
+    const sortMap = {
+      relevance: CurrentSort.relevance,
+      priceAsc: CurrentSort.priceAsc,
+      priceDesc: CurrentSort.priceDesc,
+      newest: CurrentSort.newest,
+      nameAsc: CurrentSort.nameAsc,
+      nameDesc: CurrentSort.nameDesc
+    };
+    const newSort = sortMap[value] ?? CurrentSort.relevance;
+    setSortBy({ currentSort: newSort });
+  });
+  refs.filters.priceRange.minPrice.oninput(({ event }) => {
+    const value = parseFloat(event.target.value);
+    const newValue = isNaN(value) ? 0 : value;
+    setFilters(patch(filters(), [{ op: REPLACE, path: ["priceRange", "minPrice"], value: newValue }]));
+  });
+  refs.filters.priceRange.maxPrice.oninput(({ event }) => {
+    const value = parseFloat(event.target.value);
+    const newValue = isNaN(value) ? 0 : value;
+    setFilters(patch(filters(), [{ op: REPLACE, path: ["priceRange", "maxPrice"], value: newValue }]));
+  });
+  refs.filters.priceRange.ranges.isSelected.oninput(({ event, coordinate }) => {
+    const [rangeId] = coordinate;
+    const currentFilters = filters();
+    const ranges = currentFilters.priceRange.ranges || [];
+    const selectedRange = ranges.find((r) => r.rangeId === rangeId);
+    if (!selectedRange)
+      return;
+    const updatedRanges = ranges.map((r) => ({
+      ...r,
+      isSelected: r.rangeId === rangeId
+    }));
+    const newMinPrice = selectedRange.minValue ?? 0;
+    const newMaxPrice = selectedRange.maxValue ?? 0;
+    setFilters(patch(currentFilters, [
+      { op: REPLACE, path: ["priceRange", "ranges"], value: updatedRanges },
+      { op: REPLACE, path: ["priceRange", "minPrice"], value: newMinPrice },
+      { op: REPLACE, path: ["priceRange", "maxPrice"], value: newMaxPrice }
+    ]));
+  });
+  refs.filters.categoryFilter.categories.isSelected.oninput(({ event, coordinate }) => {
+    const [categoryId] = coordinate;
+    const currentFilters = filters();
+    const categoryIndex = currentFilters.categoryFilter.categories.findIndex((c) => c.categoryId === categoryId);
+    if (categoryIndex !== -1) {
+      const isChecked = event.target.checked;
+      setFilters(patch(currentFilters, [
+        {
+          op: REPLACE,
+          path: ["categoryFilter", "categories", categoryIndex, "isSelected"],
+          value: isChecked
+        }
+      ]));
+    }
+  });
+  refs.filters.clearFilters.onclick(() => {
+    const currentFilters = filters();
+    const clearedCategories = currentFilters.categoryFilter.categories.map((cat) => ({
+      ...cat,
+      isSelected: false
+    }));
+    const clearedRanges = (currentFilters.priceRange.ranges || []).map((r, i) => ({
+      ...r,
+      isSelected: i === 0
+    }));
+    setFilters({
+      priceRange: {
+        minPrice: 0,
+        maxPrice: 0,
+        minBound: currentFilters.priceRange.minBound,
+        maxBound: currentFilters.priceRange.maxBound,
+        ranges: clearedRanges
+      },
+      categoryFilter: { categories: clearedCategories }
+    });
+  });
+  refs.loadMoreButton.onclick(() => {
+    performLoadMore();
+  });
+  refs.suggestions?.suggestionButton?.onclick(({ coordinate }) => {
+    const [suggestionId] = coordinate;
+    const suggestion = suggestions().find((s) => s.suggestionId === suggestionId);
+    if (suggestion) {
+      setSearchExpression(suggestion.suggestionText);
+      setSubmittedSearchTerm(suggestion.suggestionText);
+    }
+  });
+  refs.searchResults?.addToCartButton?.onclick(async ({ coordinate }) => {
+    const [productId] = coordinate;
+    const currentResults = searchResults();
+    const productIndex = currentResults.findIndex((p) => p._id === productId);
+    if (productIndex === -1)
+      return;
+    setSearchResults(patch(currentResults, [
+      { op: REPLACE, path: [productIndex, "isAddingToCart"], value: true }
+    ]));
+    try {
+      await storesContext.addToCart(productId, 1);
+    } catch (error) {
+      console.error("[ProductSearch V1] Failed to add to cart:", error);
+    } finally {
+      setSearchResults(patch(searchResults(), [
+        { op: REPLACE, path: [productIndex, "isAddingToCart"], value: false }
+      ]));
+    }
+  });
+  refs.searchResults?.quickOption?.choices?.choiceButton?.onclick(async ({ coordinate }) => {
+    const [productId, choiceId] = coordinate;
+    const currentResults = searchResults();
+    const productIndex = currentResults.findIndex((p) => p._id === productId);
+    if (productIndex === -1)
+      return;
+    const product = currentResults[productIndex];
+    const choice = product.quickOption?.choices?.find((c) => c.choiceId === choiceId);
+    if (!choice || !choice.inStock) {
+      console.warn("[ProductSearch V1] Choice not available or out of stock");
+      return;
+    }
+    setSearchResults(patch(currentResults, [
+      { op: REPLACE, path: [productIndex, "isAddingToCart"], value: true }
+    ]));
+    try {
+      await storesContext.addToCart(productId, 1, choice.variantId);
+    } catch (error) {
+      console.error("[ProductSearch V1] Failed to add to cart:", error);
+    } finally {
+      setSearchResults(patch(searchResults(), [
+        { op: REPLACE, path: [productIndex, "isAddingToCart"], value: false }
+      ]));
+    }
+  });
+  refs.searchResults?.viewOptionsButton?.onclick(({ coordinate }) => {
+    const [productId] = coordinate;
+    const product = searchResults().find((p) => p._id === productId);
+    if (product?.productUrl) {
+      window.location.href = product.productUrl;
+    }
+  });
+  return {
+    render: () => ({
+      searchExpression: searchExpression(),
+      isSearching: isSearching(),
+      hasSearched: hasSearched(),
+      searchResults: searchResults(),
+      resultCount: resultCount(),
+      hasResults: hasResults(),
+      hasSuggestions: hasSuggestions(),
+      suggestions: suggestions(),
+      filters: filters(),
+      sortBy: sortBy(),
+      hasMore: hasMore(),
+      loadedCount: loadedCount(),
+      totalCount: totalCount()
+    })
+  };
+}
+const productSearch = makeJayStackComponent().withProps().withContexts(WIX_STORES_V1_CONTEXT).withInteractive(ProductSearchInteractive);
+const PAGE_SIZE = 20;
+function CollectionPageInteractive(_props, refs, viewStateSignals, fastCarryForward, storesContext) {
+  const { products: [products2], loadedProducts: [loadedProducts, setLoadedProducts], hasMore: [hasMore, setHasMore], loadedCount: [loadedCount, setLoadedCount], isLoading: [isLoading, setIsLoading], hasProducts: [hasProducts, setHasProducts] } = viewStateSignals;
+  const { collectionId, totalProducts } = fastCarryForward;
+  let currentOffset = fastCarryForward.currentOffset;
+  refs.loadMoreButton?.onclick(async () => {
+    if (isLoading() || !hasMore())
+      return;
+    setIsLoading(true);
+    try {
+      const response = await storesContext.loadMoreCollectionProducts(collectionId, currentOffset, PAGE_SIZE);
+      const currentLoaded = loadedProducts();
+      setLoadedProducts([...currentLoaded, ...response.products]);
+      currentOffset += response.products.length;
+      setLoadedCount(loadedCount() + response.products.length);
+      setHasMore(currentOffset < totalProducts);
+      setHasProducts(true);
+    } catch (error) {
+      console.error("[CollectionPage V1] Failed to load more products:", error);
+    } finally {
+      setIsLoading(false);
+    }
+  });
+  refs.products?.addToCartButton?.onclick(async ({ coordinate }) => {
+    const [productId] = coordinate;
+    try {
+      await storesContext.addToCart(productId, 1);
+    } catch (error) {
+      console.error("[CollectionPage V1] Failed to add to cart:", error);
+    }
+  });
+  refs.loadedProducts?.addToCartButton?.onclick(async ({ coordinate }) => {
+    const [productId] = coordinate;
+    try {
+      await storesContext.addToCart(productId, 1);
+    } catch (error) {
+      console.error("[CollectionPage V1] Failed to add to cart:", error);
+    }
+  });
+  refs.products?.quickOption?.choices?.choiceButton?.onclick(async ({ coordinate }) => {
+    const [productId, choiceId] = coordinate;
+    try {
+      await storesContext.addToCart(productId, 1, choiceId);
+    } catch (error) {
+      console.error("[CollectionPage V1] Failed to add to cart:", error);
+    }
+  });
+  refs.loadedProducts?.quickOption?.choices?.choiceButton?.onclick(async ({ coordinate }) => {
+    const [productId, choiceId] = coordinate;
+    const product = loadedProducts().find((p) => p._id === productId);
+    if (!product)
+      return;
+    const choice = product.quickOption?.choices?.find((c) => c.choiceId === choiceId);
+    if (!choice || !choice.inStock) {
+      console.warn("[CollectionPage V1] Choice not available or out of stock");
+      return;
+    }
+    try {
+      await storesContext.addToCart(productId, 1, choice.variantId);
+    } catch (error) {
+      console.error("[CollectionPage V1] Failed to add to cart:", error);
+    }
+  });
+  refs.loadedProducts?.viewOptionsButton?.onclick(({ coordinate }) => {
+    const [productId] = coordinate;
+    const product = loadedProducts().find((p) => p._id === productId);
+    if (product?.productUrl) {
+      window.location.href = product.productUrl;
+    }
+  });
+  return {
+    render: () => ({
+      products: products2(),
+      loadedProducts: loadedProducts(),
+      hasMore: hasMore(),
+      loadedCount: loadedCount(),
+      isLoading: isLoading(),
+      hasProducts: hasProducts()
+    })
+  };
+}
+const collectionPage = makeJayStackComponent().withProps().withContexts(WIX_STORES_V1_CONTEXT).withInteractive(CollectionPageInteractive);
+const categoryPage = collectionPage;
+const collectionList = makeJayStackComponent().withProps();
+const categoryList = collectionList;
+const init = makeJayInit().withClient(async (data) => {
+  console.log("[wix-stores-v1] Initializing client-side stores context...");
+  provideWixStoresV1Context();
+  console.log("[wix-stores-v1] Client initialization complete");
+  console.log(`[wix-stores-v1] Search enabled: ${data.enableClientSearch}`);
+});
+export {
+  WIX_CART_CONTEXT,
+  WIX_STORES_V1_CONTEXT,
+  cartIndicator,
+  cartPage,
+  categoryList,
+  categoryPage,
+  collectionList,
+  collectionPage,
+  init,
+  productPage,
+  productSearch,
+  provideWixStoresV1Context
+};