@jay-framework/wix-stores 0.15.1 → 0.15.4

package/dist/index.js

@@ -44,13 +44,49 @@ function getInventoryClient(wixClient) {
 }
 const WIX_STORES_SERVICE_MARKER = createJayService("Wix Store Service");
 function provideWixStoresService(wixClient, options) {
+  let cachedTree = null;
+  const categoriesClient = getCategoriesClient(wixClient);
   const service = {
     products: getProductsV3Client(wixClient),
-    categories: getCategoriesClient(wixClient),
+    categories: categoriesClient,
     inventory: getInventoryClient(wixClient),
-    // Keep cart for backward compatibility, but prefer WIX_CART_SERVICE
     cart: getCurrentCartClient(wixClient),
-    categoryPrefixes: options?.categoryPrefixes ?? []
+    urls: options?.urls ?? { product: "/products/{slug}", category: null },
+    defaultCategory: options?.defaultCategory ?? null,
+    async getCategoryTree() {
+      if (cachedTree) return cachedTree;
+      const slugMap = /* @__PURE__ */ new Map();
+      const parentMap = /* @__PURE__ */ new Map();
+      const rootIds = /* @__PURE__ */ new Set();
+      const imageMap = /* @__PURE__ */ new Map();
+      try {
+        const processItems = (items) => {
+          for (const cat of items) {
+            if (!cat._id || !cat.slug) continue;
+            slugMap.set(cat._id, cat.slug);
+            if (cat.parentCategory?._id) {
+              parentMap.set(cat._id, cat.parentCategory._id);
+            } else {
+              rootIds.add(cat._id);
+            }
+            const imageUrl = cat.media?.mainMedia?.image?.url || cat.media?.mainMedia?.url;
+            if (imageUrl) {
+              imageMap.set(cat._id, imageUrl);
+            }
+          }
+        };
+        let result = await categoriesClient.queryCategories({ treeReference: { appNamespace: "@wix/stores" } }).eq("visible", true).limit(100).find();
+        processItems(result.items || []);
+        while (result.hasNext()) {
+          result = await result.next();
+          processItems(result.items || []);
+        }
+      } catch (error) {
+        console.error("[wix-stores] Failed to build category tree:", error);
+      }
+      cachedTree = { slugMap, parentMap, rootIds, imageMap };
+      return cachedTree;
+    }
   };
   registerService(WIX_STORES_SERVICE_MARKER, service);
   return service;
@@ -80,7 +116,8 @@ var ProductType$1 = /* @__PURE__ */ ((ProductType2) => {
 var QuickAddType = /* @__PURE__ */ ((QuickAddType2) => {
   QuickAddType2[QuickAddType2["SIMPLE"] = 0] = "SIMPLE";
   QuickAddType2[QuickAddType2["SINGLE_OPTION"] = 1] = "SINGLE_OPTION";
-  QuickAddType2[QuickAddType2["NEEDS_CONFIGURATION"] = 2] = "NEEDS_CONFIGURATION";
+  QuickAddType2[QuickAddType2["COLOR_AND_TEXT_OPTIONS"] = 2] = "COLOR_AND_TEXT_OPTIONS";
+  QuickAddType2[QuickAddType2["NEEDS_CONFIGURATION"] = 3] = "NEEDS_CONFIGURATION";
   return QuickAddType2;
 })(QuickAddType || {});
 var OptionRenderType$1 = /* @__PURE__ */ ((OptionRenderType2) => {
@@ -136,33 +173,54 @@ function formatWixMediaUrl(_id, url, resize) {
   }
   return "";
 }
-function resolveProductPrefix(product, prefixConfig) {
-  if (!prefixConfig?.length || !product.allCategoriesInfo?.categories) {
-    return null;
-  }
-  const productCategoryIds = new Set(
-    product.allCategoriesInfo.categories.map((c) => c._id).filter(Boolean)
-  );
-  for (const { categoryId, prefix } of prefixConfig) {
-    if (productCategoryIds.has(categoryId)) {
-      return prefix;
+function findRootCategoryId(categoryId, tree) {
+  let current = categoryId;
+  for (let depth = 0; depth < 20; depth++) {
+    if (tree.rootIds.has(current)) {
+      return current;
     }
+    const parentId = tree.parentMap.get(current);
+    if (!parentId) return current;
+    current = parentId;
   }
-  return null;
+  return current;
 }
-function resolveProductPrefixConfig(product, prefixConfig) {
-  if (!prefixConfig?.length || !product.allCategoriesInfo?.categories) {
-    return null;
+function findRootCategorySlug(categoryId, tree) {
+  const rootId = findRootCategoryId(categoryId, tree);
+  return tree.slugMap.get(rootId) ?? "";
+}
+function findCategoryImage(categoryId, tree) {
+  let current = categoryId;
+  for (let depth = 0; depth < 20 && current; depth++) {
+    const image = tree.imageMap.get(current);
+    if (image) return image;
+    current = tree.parentMap.get(current);
   }
-  const productCategoryIds = new Set(
-    product.allCategoriesInfo.categories.map((c) => c._id).filter(Boolean)
-  );
-  for (const config of prefixConfig) {
-    if (productCategoryIds.has(config.categoryId)) {
-      return config;
-    }
+  return "";
+}
+function buildProductUrl(urls, tree, slug, mainCategoryId) {
+  let url = urls.product;
+  url = url.replace("{slug}", slug);
+  if (url.includes("{category}")) {
+    const categorySlug = tree.slugMap.get(mainCategoryId);
+    url = url.replace("{category}", categorySlug);
   }
-  return null;
+  if (url.includes("{prefix}")) {
+    const prefixSlug = findRootCategorySlug(mainCategoryId, tree);
+    url = url.replace("{prefix}", prefixSlug);
+  }
+  return url;
+}
+function buildCategoryUrl(urls, tree, categorySlug, categoryId) {
+  if (!urls.category) return null;
+  let url = urls.category;
+  url = url.replace("{category}", categorySlug);
+  if (url.includes("{prefix}")) {
+    const prefixSlug = findRootCategorySlug(categoryId, tree);
+    if (!prefixSlug) return null;
+    url = url.replace("{prefix}", prefixSlug);
+  }
+  return url.includes("{") ? null : url;
 }
 function mapAvailabilityStatus(status) {
   switch (status) {
@@ -198,7 +256,15 @@ function isValidPrice(amount) {
 function getQuickAddType(product) {
   const optionCount = product.options?.length ?? 0;
   const hasModifiers = (product.modifiers?.length ?? 0) > 0;
-  if (hasModifiers || optionCount > 1) {
+  if (hasModifiers || optionCount > 2) {
+    return QuickAddType.NEEDS_CONFIGURATION;
+  }
+  if (optionCount === 2) {
+    const hasColor = product.options.some((o) => o.optionRenderType === "SWATCH_CHOICES");
+    const hasText = product.options.some((o) => o.optionRenderType === "TEXT_CHOICES");
+    if (hasColor && hasText) {
+      return QuickAddType.COLOR_AND_TEXT_OPTIONS;
+    }
     return QuickAddType.NEEDS_CONFIGURATION;
   }
   if (optionCount === 1) {
@@ -214,31 +280,85 @@ function mapChoiceType(choiceType) {
 }
 function mapQuickOption(option, variantsInfo) {
   if (!option) return null;
-  const optionId = option._id;
   const choices = option.choicesSettings?.choices || [];
   return {
-    _id: optionId,
+    _id: option._id || "",
     name: option.name || "",
     optionRenderType: mapOptionRenderType(option.optionRenderType),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    choices: choices.map((choice) => {
-      return {
-        choiceId: choice.choiceId,
-        name: choice.name || "",
-        choiceType: mapChoiceType(choice.choiceType),
-        colorCode: choice.colorCode || "",
-        inStock: choice.inStock,
-        isSelected: false
-      };
-    })
+    choices: choices.map((choice) => ({
+      choiceId: choice.choiceId || "",
+      name: choice.name || "",
+      choiceType: mapChoiceType(choice.choiceType),
+      colorCode: choice.colorCode || "",
+      inStock: choice.inStock ?? true,
+      isSelected: false
+    }))
   };
 }
-const DEFAULT_PRODUCT_PAGE_PATH = "/products";
-function mapProductToCard(product, productPagePath = DEFAULT_PRODUCT_PAGE_PATH, prefixConfig) {
+function mapQuickAddOptions(product) {
+  const quickAddType = getQuickAddType(product);
+  if (quickAddType === QuickAddType.COLOR_AND_TEXT_OPTIONS) {
+    const colorOption = product.options.find((o) => o.optionRenderType === "SWATCH_CHOICES");
+    const textOption = product.options.find((o) => o.optionRenderType === "TEXT_CHOICES");
+    const quickOption = mapQuickOption(colorOption, product.variantsInfo);
+    const secondQuickOption = mapQuickOption(textOption, product.variantsInfo);
+    if (quickOption?.choices) {
+      const firstInStock = quickOption.choices.find((c) => c.inStock);
+      if (firstInStock) {
+        firstInStock.isSelected = true;
+      }
+    }
+    if (secondQuickOption?.choices) {
+      for (const choice of secondQuickOption.choices) {
+        choice.inStock = false;
+      }
+    }
+    return { quickAddType, quickOption, secondQuickOption };
+  }
+  if (quickAddType === QuickAddType.SINGLE_OPTION) {
+    return {
+      quickAddType,
+      quickOption: mapQuickOption(product.options?.[0], product.variantsInfo),
+      secondQuickOption: null
+    };
+  }
+  return { quickAddType, quickOption: null, secondQuickOption: null };
+}
+function buildVariantStockMap(product) {
+  const stockMap = {};
+  const options = product.options;
+  const variants = product.variantsInfo?.variants;
+  if (!options || options.length !== 2 || !variants) return stockMap;
+  const colorOption = options.find((o) => o.optionRenderType === "COLOR_SWATCH_CHOICES");
+  const textOption = options.find((o) => o.optionRenderType !== "COLOR_SWATCH_CHOICES");
+  if (!colorOption || !textOption) return stockMap;
+  const colorOptionId = colorOption._id || "";
+  const textOptionId = textOption._id || "";
+  const colorChoices = colorOption.choicesSettings?.choices || [];
+  const textChoices = textOption.choicesSettings?.choices || [];
+  for (const colorChoice of colorChoices) {
+    const cId = colorChoice.choiceId || "";
+    stockMap[cId] = {};
+    for (const textChoice of textChoices) {
+      const tId = textChoice.choiceId || "";
+      const variant = variants.find(
+        (v) => v.choices?.some(
+          (c) => c.optionChoiceIds?.optionId === colorOptionId && c.optionChoiceIds?.choiceId === cId
+        ) && v.choices?.some(
+          (c) => c.optionChoiceIds?.optionId === textOptionId && c.optionChoiceIds?.choiceId === tId
+        )
+      );
+      stockMap[cId][tId] = variant?.inventoryStatus?.inStock ?? false;
+    }
+  }
+  return stockMap;
+}
+function mapProductToCard(product, urls, tree) {
   const mainMedia = product.media?.main;
   const slug = product.slug || "";
-  const matchedPrefix = prefixConfig?.length ? resolveProductPrefixConfig(product, prefixConfig) : null;
-  const productUrl = slug ? matchedPrefix ? `${productPagePath}/${matchedPrefix.prefix}/${slug}` : `${productPagePath}/${slug}` : "";
+  const mainCategoryId = product.mainCategoryId || "";
+  const productUrl = buildProductUrl(urls, tree, slug, mainCategoryId);
+  const categoryName = tree.slugMap.get(mainCategoryId);
   const firstVariant = product.variantsInfo?.variants?.[0];
   const variantPrice = firstVariant?.price;
   const actualAmount = variantPrice?.actualPrice?.amount || product.actualPriceRange?.minValue?.amount || "0";
@@ -251,7 +371,7 @@ function mapProductToCard(product, productPagePath = DEFAULT_PRODUCT_PAGE_PATH,
     name: product.name || "",
     slug,
     productUrl,
-    categoryPrefix: matchedPrefix?.name ?? "",
+    categoryPrefix: categoryName,
     mainMedia: {
       url: mainMedia ? formatWixMediaUrl(mainMedia._id, mainMedia.url) : "",
       altText: mainMedia?.altText || product.name || "",
@@ -263,7 +383,6 @@ function mapProductToCard(product, productPagePath = DEFAULT_PRODUCT_PAGE_PATH,
       width: 300,
       height: 300
     },
-    // Simplified price fields
     price: actualFormattedAmount,
     strikethroughPrice: hasDiscount ? compareAtFormattedAmount : "",
     hasDiscount,
@@ -282,11 +401,13 @@ function mapProductToCard(product, productPagePath = DEFAULT_PRODUCT_PAGE_PATH,
     },
     productType: mapProductType$1(product.productType),
     isAddingToCart: false,
-    // Quick add behavior
-    quickAddType: getQuickAddType(product),
-    quickOption: getQuickAddType(product) === QuickAddType.SINGLE_OPTION ? mapQuickOption(product.options?.[0], product.variantsInfo) : null
+    ...mapQuickAddOptions(product)
   };
 }
+function needsCategoryInfo(wixStores) {
+  const template = wixStores.urls.product;
+  return template.includes("{category}") || template.includes("{prefix}");
+}
 const PRICE_BUCKET_BOUNDARIES = [
   0,
   20,
@@ -397,18 +518,16 @@ const searchProducts = makeJayQuery("wixStores.searchProducts").withServices(WIX
       const searchResult = await wixStores.products.searchProducts(
         {
           filter,
-          // @ts-expect-error - Wix SDK types don't match actual API
           sort: sort.length > 0 ? sort : void 0,
           cursorPaging,
           search,
-          // @ts-expect-error - Wix SDK types don't include aggregations
           aggregations
         },
         {
           fields: [
             "CURRENCY",
             "VARIANT_OPTION_CHOICE_NAMES",
-            ...wixStores.categoryPrefixes.length > 0 ? ["ALL_CATEGORIES_INFO"] : []
+            ...needsCategoryInfo(wixStores) ? ["ALL_CATEGORIES_INFO"] : []
           ]
         }
       );
@@ -448,9 +567,9 @@ const searchProducts = makeJayQuery("wixStores.searchProducts").withServices(WIX
         };
       });
       priceRanges.push(...bucketRanges);
-      const prefixConfig = wixStores.categoryPrefixes;
+      const tree = await wixStores.getCategoryTree();
       const mappedProducts = products.map(
-        (p) => mapProductToCard(p, "/products", prefixConfig)
+        (p) => mapProductToCard(p, wixStores.urls, tree)
       );
       return {
         products: mappedProducts,
@@ -476,11 +595,10 @@ const getProductBySlug = makeJayQuery("wixStores.getProductBySlug").withServices
       throw new ActionError("INVALID_INPUT", "Product slug is required");
     }
     try {
-      const prefixConfig = wixStores.categoryPrefixes;
       const fields = [
         "MEDIA_ITEMS_INFO",
         "VARIANT_OPTION_CHOICE_NAMES",
-        ...prefixConfig.length > 0 ? ["ALL_CATEGORIES_INFO"] : []
+        ...needsCategoryInfo(wixStores) ? ["ALL_CATEGORIES_INFO"] : []
       ];
       const result = await wixStores.products.getProductBySlug(slug, {
         fields: [...fields]
@@ -489,13 +607,27 @@ const getProductBySlug = makeJayQuery("wixStores.getProductBySlug").withServices
       if (!product) {
         return null;
       }
-      return mapProductToCard(product, "/products", prefixConfig);
+      const tree = await wixStores.getCategoryTree();
+      return mapProductToCard(product, wixStores.urls, tree);
     } catch (error) {
       console.error("[wixStores.getProductBySlug] Failed to get product:", error);
       return null;
     }
   }
 );
+const getVariantStock = makeJayQuery("wixStores.getVariantStock").withServices(WIX_STORES_SERVICE_MARKER).withHandler(
+  async (input, wixStores) => {
+    try {
+      const product = await wixStores.products.getProduct(input.productId, {
+        fields: ["VARIANT_OPTION_CHOICE_NAMES"]
+      });
+      return buildVariantStockMap(product);
+    } catch (error) {
+      console.error("[wixStores.getVariantStock] Failed:", error);
+      return {};
+    }
+  }
+);
 const getCategories = makeJayQuery("wixStores.getCategories").withServices(WIX_STORES_SERVICE_MARKER).withCaching({ maxAge: 3600 }).withHandler(
   async (_input, wixStores) => {
     try {
@@ -515,11 +647,153 @@ const getCategories = makeJayQuery("wixStores.getCategories").withServices(WIX_S
   }
 );
 const PAGE_SIZE = 12;
+function 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";
+  }
+}
+function parseUrlFilters(url) {
+  try {
+    const params = new URL(url, "http://x").searchParams;
+    return {
+      searchTerm: params.get("q") || "",
+      selectedCategorySlugs: params.get("cat")?.split(",").filter(Boolean) || [],
+      minPrice: params.has("min") ? Number(params.get("min")) : null,
+      maxPrice: params.has("max") ? Number(params.get("max")) : null,
+      inStockOnly: params.get("inStock") === "1",
+      sort: params.get("sort") || "relevance"
+    };
+  } catch {
+    return {
+      searchTerm: "",
+      selectedCategorySlugs: [],
+      minPrice: null,
+      maxPrice: null,
+      inStockOnly: false,
+      sort: "relevance"
+    };
+  }
+}
+function parseSortParam(sort) {
+  const sortMap = {
+    relevance: CurrentSort.relevance,
+    priceAsc: CurrentSort.priceAsc,
+    priceDesc: CurrentSort.priceDesc,
+    newest: CurrentSort.newest,
+    nameAsc: CurrentSort.nameAsc,
+    nameDesc: CurrentSort.nameDesc
+  };
+  return sortMap[sort] ?? CurrentSort.relevance;
+}
+const EMPTY_CATEGORY_HEADER = {
+  name: "",
+  description: "",
+  imageUrl: "",
+  hasImage: false,
+  productCount: 0,
+  breadcrumbs: [],
+  seoData: { tags: [], settings: { preventAutoRedirect: false, keywords: [] } }
+};
+async function findCategoryBySlug(categoriesClient, slug) {
+  const result = await categoriesClient.queryCategories({ treeReference: { appNamespace: "@wix/stores" } }).eq("slug", slug).eq("visible", true).limit(1).find();
+  return result.items?.[0] ?? null;
+}
+async function loadCategoryDetails(categoriesClient, categoryId) {
+  try {
+    return await categoriesClient.getCategory(categoryId, { appNamespace: "@wix/stores" }, { fields: ["DESCRIPTION", "BREADCRUMBS_INFO"] });
+  } catch {
+    return null;
+  }
+}
+async function buildCategoryHeader(wixStoreService, category, categoryUrlTemplate) {
+  const details = await loadCategoryDetails(wixStoreService.categories, category._id);
+  const cat = details || category;
+  const imageUrl = cat.image || "";
+  const description = cat.description || "";
+  const categoryTree = await wixStoreService.getCategoryTree();
+  const breadcrumbs = (cat.breadcrumbsInfo?.breadcrumbs || []).map((b) => ({
+    categoryId: b.categoryId,
+    name: b.categoryName,
+    slug: b.categorySlug,
+    url: categoryUrlTemplate ? buildCategoryUrl(wixStoreService.urls, categoryTree, b.categorySlug, b.categoryId) : ""
+  }));
+  const seoData = cat.seoData ? {
+    tags: (cat.seoData.tags || []).map((tag, index) => ({
+      position: index.toString().padStart(2, "0"),
+      type: tag.type || "",
+      props: Object.entries(tag.props || {}).map(([key, value]) => ({
+        key,
+        value
+      })),
+      meta: Object.entries(tag.meta || {}).map(([key, value]) => ({
+        key,
+        value
+      })),
+      children: tag.children || ""
+    })),
+    settings: {
+      preventAutoRedirect: cat.seoData.settings?.preventAutoRedirect || false,
+      keywords: (cat.seoData.settings?.keywords || []).map((k) => ({
+        term: k.term || "",
+        isMain: k.isMain || false,
+        origin: k.origin || ""
+      }))
+    }
+  } : EMPTY_CATEGORY_HEADER.seoData;
+  let header = {
+    name: cat.name || "",
+    description,
+    imageUrl,
+    hasImage: !!imageUrl,
+    productCount: cat.itemCounter || 0,
+    breadcrumbs,
+    seoData
+  };
+  if ((!description || !imageUrl) && cat.parentCategory?._id) {
+    const parent = await loadCategoryDetails(wixStoreService.categories, cat.parentCategory._id);
+    if (parent) {
+      if (!header.description && parent.description) {
+        header = { ...header, description: parent.description };
+      }
+      if (!header.imageUrl) {
+        const parentImage = parent.image || "";
+        if (parentImage) {
+          header = { ...header, imageUrl: parentImage, hasImage: true };
+        }
+      }
+    }
+  }
+  return header;
+}
 async function renderSlowlyChanging$2(props, wixStores) {
   const Pipeline = RenderPipeline.for();
-  const categoryPrefix = props.category;
-  const categoryConfig = categoryPrefix ? wixStores.categoryPrefixes.find((c) => c.prefix === categoryPrefix) : null;
-  const baseCategoryId = categoryConfig?.categoryId ?? null;
+  const subcategorySlug = props.subcategory ?? null;
+  const categorySlug = props.category ?? null;
+  const defaultCategorySlug = wixStores.defaultCategory;
+  let activeCategory = null;
+  let baseCategoryId = null;
+  if (subcategorySlug) {
+    activeCategory = await findCategoryBySlug(wixStores.categories, subcategorySlug);
+    baseCategoryId = activeCategory?._id ?? null;
+  } else if (categorySlug) {
+    activeCategory = await findCategoryBySlug(wixStores.categories, categorySlug);
+    baseCategoryId = activeCategory?._id ?? null;
+  } else if (defaultCategorySlug) {
+    activeCategory = await findCategoryBySlug(wixStores.categories, defaultCategorySlug);
+  }
+  const tree = await wixStores.getCategoryTree();
+  const categoryHeader = activeCategory ? await buildCategoryHeader(wixStores, activeCategory, wixStores.urls.category) : EMPTY_CATEGORY_HEADER;
   return Pipeline.try(async () => {
     let query = wixStores.categories.queryCategories({
       treeReference: { appNamespace: "@wix/stores" }
@@ -536,7 +810,8 @@ async function renderSlowlyChanging$2(props, wixStores) {
     const categoryInfos = categories2.map((cat) => ({
       categoryId: cat._id || "",
       categoryName: cat.name || "",
-      categorySlug: cat.slug || ""
+      categorySlug: cat.slug || "",
+      categoryUrl: buildCategoryUrl(wixStores.urls, tree, cat.slug || "", cat._id || "") ?? ""
     }));
     return {
       viewState: {
@@ -547,7 +822,8 @@ async function renderSlowlyChanging$2(props, wixStores) {
           categoryFilter: {
             categories: categoryInfos
           }
-        }
+        },
+        categoryHeader
       },
       carryForward: {
         searchFields: "name,description,sku",
@@ -560,11 +836,20 @@ async function renderSlowlyChanging$2(props, wixStores) {
 }
 async function renderFastChanging$1(props, slowCarryForward, _wixStores) {
   const Pipeline = RenderPipeline.for();
+  const urlFilters = parseUrlFilters(props.url);
+  const initialSort = parseSortParam(urlFilters.sort);
+  const initialCategoryIds = urlFilters.selectedCategorySlugs.map((slug) => slowCarryForward.categories.find((c) => c.categorySlug === slug)?.categoryId).filter(Boolean);
   return Pipeline.try(async () => {
-    const baseCategoryIds = slowCarryForward.baseCategoryId ? [slowCarryForward.baseCategoryId] : [];
+    const baseCategoryIds = slowCarryForward.baseCategoryId ? [slowCarryForward.baseCategoryId, ...initialCategoryIds] : initialCategoryIds;
     const result = await searchProducts({
-      query: "",
-      filters: baseCategoryIds.length > 0 ? { categoryIds: baseCategoryIds } : void 0,
+      query: urlFilters.searchTerm || "",
+      filters: {
+        categoryIds: baseCategoryIds.length > 0 ? baseCategoryIds : void 0,
+        minPrice: urlFilters.minPrice ?? void 0,
+        maxPrice: urlFilters.maxPrice ?? void 0,
+        inStockOnly: urlFilters.inStockOnly || void 0
+      },
+      sortBy: initialSort !== CurrentSort.relevance ? mapSortToAction(initialSort) : void 0,
       pageSize: PAGE_SIZE
     });
     return result;
@@ -607,20 +892,19 @@ async function renderFastChanging$1(props, slowCarryForward, _wixStores) {
     };
     return {
       viewState: {
-        searchExpression: "",
+        searchExpression: urlFilters.searchTerm,
         isSearching: false,
-        hasSearched: false,
+        hasSearched: !!urlFilters.searchTerm,
         searchResults: result.products,
         resultCount: result.products.length,
         hasResults: result.products.length > 0,
         hasSuggestions: false,
         suggestions: [],
         filters: {
-          inStockOnly: false,
+          inStockOnly: urlFilters.inStockOnly,
           priceRange: {
-            // Initialize sliders to full range (bounds)
-            minPrice: priceAgg.minBound,
-            maxPrice: priceAgg.maxBound,
+            minPrice: urlFilters.minPrice ?? priceAgg.minBound,
+            maxPrice: urlFilters.maxPrice ?? priceAgg.maxBound,
             minBound: priceAgg.minBound,
             maxBound: priceAgg.maxBound,
             ranges: priceAgg.ranges
@@ -628,12 +912,12 @@ async function renderFastChanging$1(props, slowCarryForward, _wixStores) {
           categoryFilter: {
             categories: slowCarryForward.categories.map((cat) => ({
               categoryId: cat.categoryId,
-              isSelected: false
+              isSelected: initialCategoryIds.includes(cat.categoryId)
             }))
           }
         },
         sortBy: {
-          currentSort: CurrentSort.relevance
+          currentSort: initialSort
         },
         hasMore: result.hasMore,
         loadedCount: result.products.length,
@@ -648,7 +932,29 @@ async function renderFastChanging$1(props, slowCarryForward, _wixStores) {
     };
   });
 }
-const productSearch = makeJayStackComponent().withProps().withServices(WIX_STORES_SERVICE_MARKER).withSlowlyRender(renderSlowlyChanging$2).withFastRender(renderFastChanging$1);
+async function* loadSearchParams([wixStores]) {
+  try {
+    const result = await wixStores.categories.queryCategories({
+      treeReference: { appNamespace: "@wix/stores" }
+    }).eq("visible", true).limit(100).find();
+    const categories2 = result.items || [];
+    yield categories2.filter((cat) => cat.slug && (cat.itemCounter ?? 0) > 0).map((cat) => ({
+      category: cat.slug
+    }));
+    for (const cat of categories2) {
+      if (!cat.slug || !cat.parentCategory?._id || (cat.itemCounter ?? 0) === 0)
+        continue;
+      const parent = categories2.find((c) => c._id === cat.parentCategory?._id);
+      if (parent?.slug) {
+        yield [{ category: parent.slug, subcategory: cat.slug }];
+      }
+    }
+  } catch (error) {
+    console.error("Failed to load category params:", error);
+    yield [];
+  }
+}
+const productSearch = makeJayStackComponent().withProps().withServices(WIX_STORES_SERVICE_MARKER).withLoadParams(loadSearchParams).withSlowlyRender(renderSlowlyChanging$2).withFastRender(renderFastChanging$1);
 var ProductType = /* @__PURE__ */ ((ProductType2) => {
   ProductType2[ProductType2["PHYSICAL"] = 0] = "PHYSICAL";
   ProductType2[ProductType2["DIGITAL"] = 1] = "DIGITAL";
@@ -691,28 +997,21 @@ var MediaType = /* @__PURE__ */ ((MediaType2) => {
   return MediaType2;
 })(MediaType || {});
 async function* loadProductParams([wixStores]) {
-  const prefixConfig = wixStores.categoryPrefixes;
-  const hasPrefixes = prefixConfig.length > 0;
-  const fields = hasPrefixes ? ["ALL_CATEGORIES_INFO"] : [];
+  const template = wixStores.urls.product;
+  const needsCategories = template.includes("{category}") || template.includes("{prefix}");
+  const fields = needsCategories ? ["ALL_CATEGORIES_INFO"] : [];
   try {
     let result = await wixStores.products.queryProducts({ fields: [...fields] }).find();
-    yield result.items.map((product) => mapProductToParams(product, prefixConfig));
+    yield result.items.map((product) => ({ slug: product.slug ?? "" })).filter((p) => p.slug);
     while (result.hasNext()) {
       result = await result.next();
-      yield result.items.map((product) => mapProductToParams(product, prefixConfig));
+      yield result.items.map((product) => ({ slug: product.slug ?? "" })).filter((p) => p.slug);
     }
   } catch (error) {
     console.error("Failed to load product slugs:", error);
     yield [];
   }
 }
-function mapProductToParams(product, prefixConfig) {
-  const prefix = resolveProductPrefix(product, prefixConfig);
-  return {
-    slug: product.slug ?? "",
-    ...prefix ? { category: prefix } : {}
-  };
-}
 function mapProductType(productType) {
   return productType === "DIGITAL" ? ProductType.DIGITAL : ProductType.PHYSICAL;
 }
@@ -848,8 +1147,8 @@ function mapVariants(variantsInfo) {
 }
 async function renderSlowlyChanging$1(props, wixStores) {
   const Pipeline = RenderPipeline.for();
-  const prefixConfig = wixStores.categoryPrefixes;
-  const hasPrefixes = prefixConfig.length > 0;
+  const template = wixStores.urls.product;
+  const needsCategories = template.includes("{category}") || template.includes("{prefix}");
   return Pipeline.try(async () => {
     const fields = [
       "INFO_SECTION",
@@ -857,17 +1156,11 @@ async function renderSlowlyChanging$1(props, wixStores) {
       "MEDIA_ITEMS_INFO",
       "PLAIN_DESCRIPTION",
       "CURRENCY",
-      ...hasPrefixes ? ["ALL_CATEGORIES_INFO"] : []
+      ...needsCategories ? ["ALL_CATEGORIES_INFO"] : []
     ];
     const response = await wixStores.products.getProductBySlug(props.slug, {
       fields: [...fields]
     });
-    if (props.category && hasPrefixes) {
-      const actualPrefix = resolveProductPrefix(response.product, prefixConfig);
-      if (actualPrefix !== props.category) {
-        throw new Error("Category prefix mismatch");
-      }
-    }
     return response;
   }).recover((error) => {
     console.log("product page error", error);
@@ -960,37 +1253,38 @@ const categoryList = makeJayStackComponent().withProps().withServices(WIX_STORES
 const WIX_STORES_CONTEXT = createJayContext();
 function loadWixStoresConfig() {
   const configPath = path.join(process.cwd(), "config", ".wix-stores.yaml");
+  const defaults = {
+    urls: { product: "/products/{slug}", category: null },
+    defaultCategory: null
+  };
   if (!fs.existsSync(configPath)) {
-    return { categoryPrefixes: [] };
+    return defaults;
   }
   const fileContents = fs.readFileSync(configPath, "utf8");
   const raw = yaml.load(fileContents);
   if (!raw) {
-    return { categoryPrefixes: [] };
+    return defaults;
   }
-  const prefixes = [];
-  if (Array.isArray(raw.categoryPrefixes)) {
-    for (const entry of raw.categoryPrefixes) {
-      if (typeof entry.categoryId === "string" && typeof entry.prefix === "string") {
-        prefixes.push({
-          categoryId: entry.categoryId.trim(),
-          prefix: entry.prefix.trim(),
-          name: typeof entry.name === "string" ? entry.name.trim() : entry.prefix.trim()
-        });
-      }
-    }
-  }
-  return { categoryPrefixes: prefixes };
+  const urls = raw.urls;
+  return {
+    urls: {
+      product: typeof urls?.product === "string" ? urls.product : defaults.urls.product,
+      category: typeof urls?.category === "string" ? urls.category : null
+    },
+    defaultCategory: typeof raw.defaultCategory === "string" ? raw.defaultCategory : null
+  };
 }
 const init = makeJayInit().withServer(async () => {
   console.log("[wix-stores] Initializing Wix Stores service...");
   const wixClient = getService(WIX_CLIENT_SERVICE);
   const storesConfig = loadWixStoresConfig();
   provideWixStoresService(wixClient, {
-    categoryPrefixes: storesConfig.categoryPrefixes
+    urls: storesConfig.urls,
+    defaultCategory: storesConfig.defaultCategory
   });
-  if (storesConfig.categoryPrefixes.length > 0) {
-    console.log(`[wix-stores] Category prefixes configured: ${storesConfig.categoryPrefixes.map((p) => p.prefix).join(", ")}`);
+  console.log(`[wix-stores] URL templates: product="${storesConfig.urls.product}", category="${storesConfig.urls.category ?? "none"}"`);
+  if (storesConfig.defaultCategory) {
+    console.log(`[wix-stores] Default category: ${storesConfig.defaultCategory}`);
   }
   console.log("[wix-stores] Server initialization complete");
   return {
@@ -1001,20 +1295,22 @@ const init = makeJayInit().withServer(async () => {
 const CONFIG_FILE_NAME = ".wix-stores.yaml";
 const CONFIG_TEMPLATE = `# Wix Stores Configuration
 #
-# Category Prefixes (optional):
-# Maps root Wix categories to URL prefix slugs.
-# Products under a root category get URLs like /products/{prefix}/{product-slug}
-# Each prefix gets its own search/listing page and product page templates.
+# URL templates for link generation.
+# Placeholders: {slug} (product), {category} (sub-category), {prefix} (root category)
+#
+# urls:
+#   product: "/products/{slug}"                              # simple (default)
+#   product: "/products/{category}/{slug}"                   # with categories
+#   product: "/products/{prefix}/{category}/{slug}"          # with prefixes + categories
+#   category: "/products/{prefix}/{category}"                # category deep-link pages
 #
-# To find category IDs, use: jay-stack action wix-stores/getCategories
+# Fallback category for pages without category context:
+# defaultCategory: "all-products"
 #
-# categoryPrefixes:
-#   - categoryId: "<root-category-id>"
-#     prefix: "<url-prefix>"
-#     name: "<display-name>"
-#   - categoryId: "<another-root-category-id>"
-#     prefix: "<another-url-prefix>"
-#     name: "<another-display-name>"
+# To see available categories: jay-stack setup wix-stores (generates category tree reference)
+
+urls:
+  product: "/products/{slug}"
 `;
 async function setupWixStores(ctx) {
   if (ctx.initError) {
@@ -1041,8 +1337,7 @@ async function setupWixStores(ctx) {
     configCreated.push(`config/${CONFIG_FILE_NAME}`);
   }
   const service = getService(WIX_STORES_SERVICE_MARKER);
-  const prefixCount = service.categoryPrefixes.length;
-  const message = prefixCount > 0 ? `Wix Stores configured with ${prefixCount} category prefix(es): ${service.categoryPrefixes.map((p) => p.prefix).join(", ")}` : "Wix Stores service verified";
+  const message = `Wix Stores configured (product URL: ${service.urls.product})`;
   return {
     status: "configured",
     message,
@@ -1091,22 +1386,13 @@ async function generateWixStoresReferences(ctx) {
       roots.push(node);
     }
   }
-  const prefixConfig = storesService.categoryPrefixes;
-  const configuredPrefixes = prefixConfig.map((p) => ({
-    categoryId: p.categoryId,
-    prefix: p.prefix,
-    name: p.name,
-    categoryName: nodeMap.get(p.categoryId)?.name ?? "unknown"
-  }));
   const categoriesPath = path.join(ctx.referencesDir, "categories.yaml");
   fs.writeFileSync(
     categoriesPath,
     yaml.dump(
       {
-        _generated: (/* @__PURE__ */ new Date()).toISOString(),
-        _description: "Wix Stores category tree for agent discovery. Shows category hierarchy, IDs, product counts, and configured URL prefixes.",
+        _description: "Wix Stores category tree for agent discovery. Shows category hierarchy, IDs, slugs, product counts, and parent-child relationships.",
         totalCategories: allCategories.length,
-        configuredPrefixes: configuredPrefixes.length > 0 ? configuredPrefixes : void 0,
         categoryTree: roots
       },
       { indent: 2, lineWidth: 120, noRefs: true }
@@ -1123,12 +1409,18 @@ export {
   WIX_CART_SERVICE,
   WIX_STORES_CONTEXT,
   WIX_STORES_SERVICE_MARKER,
+  buildCategoryUrl,
+  buildProductUrl,
   cartIndicator,
   cartPage,
   categoryList,
+  findCategoryImage,
+  findRootCategoryId,
+  findRootCategorySlug,
   generateWixStoresReferences,
   getCategories,
   getProductBySlug,
+  getVariantStock,
   init,
   productPage,
   productSearch,