@zenky/storefront-vue 0.9.47 → 0.10.0

package/dist/chunk-IGDDWGS4.js

@@ -0,0 +1,557 @@
+import { createRuntimeState } from './chunk-5QCUH3FF.js';
+import { useStoreProfileStore, useAuthStore } from './chunk-PWHIDGKW.js';
+import { createDebounce } from './chunk-XUGXLJZB.js';
+import { useRuntime } from './chunk-V3VVDQIR.js';
+import { UnitType } from '@zenky/storefront-api';
+import { computed, ref, watch } from 'vue';
+
+var UNIT_LABELS = {
+  [UnitType.Gram]: "\u0433",
+  [UnitType.Kilogram]: "\u043A\u0433",
+  [UnitType.Meter]: "\u043C",
+  [UnitType.Piece]: "\u0433"
+};
+function getWeightFromDimensions(variants) {
+  if (!variants?.length) return null;
+  const dimension = variants[0]?.dimensions?.find((d) => d.dimension === "weight");
+  return dimension?.value ?? null;
+}
+function getVariantWeight(variant) {
+  if (!variant) return null;
+  return variant.dimensions?.find((d) => d.dimension === "weight")?.value ?? null;
+}
+function getProductWeight(product) {
+  return product.weight ?? getWeightFromDimensions(product.variants) ?? null;
+}
+function toGrams(weight, unitType) {
+  if (!weight) {
+    return null;
+  }
+  if (unitType === UnitType.Kilogram) {
+    return weight * 1e3;
+  }
+  if (unitType === UnitType.Meter) {
+    return null;
+  }
+  return weight;
+}
+function formatWeight(weight, unitType) {
+  if (!weight) {
+    return null;
+  }
+  const label = UNIT_LABELS[unitType];
+  return `${weight} ${label}`;
+}
+function useProductsByCategory(products, categories) {
+  const grouped = computed(() => {
+    if (!categories.value.length || !products.value.length) {
+      return [];
+    }
+    const productsByCategory = /* @__PURE__ */ new Map();
+    for (const product of products.value) {
+      for (const category of product.categories) {
+        const existing = productsByCategory.get(category.id) ?? [];
+        existing.push(product);
+        productsByCategory.set(category.id, existing);
+      }
+    }
+    return flattenCategories(categories.value).filter((category) => productsByCategory.has(category.id)).map((category) => ({
+      id: category.id,
+      shortId: category.short_id,
+      slug: category.slug,
+      name: category.name,
+      products: productsByCategory.get(category.id) ?? []
+    }));
+  });
+  return { grouped };
+}
+function flattenCategories(categories) {
+  const result = [];
+  for (const category of categories) {
+    result.push(category);
+    if (category.children?.length) {
+      result.push(...flattenCategories(category.children));
+    }
+  }
+  return result;
+}
+function getInitialModifiersModel(variant) {
+  if (!variant?.default_modifiers?.modifiers.length) {
+    return [];
+  }
+  return variant.default_modifiers.modifiers.map((modifier) => ({
+    modifier_id: modifier.modifier_id,
+    modifiers_group_id: modifier.modifiers_group_id,
+    quantity: modifier.quantity
+  }));
+}
+function useProductVariantModifiers(variant) {
+  const modifiersModel = ref([
+    ...getInitialModifiersModel(variant.value)
+  ]);
+  const selectedModifiersHash = ref(null);
+  const hasAnyModifier = computed(() => modifiersModel.value.length > 0);
+  watch(variant, () => {
+    const newDefaults = getInitialModifiersModel(variant.value);
+    const userStandalone = modifiersModel.value.filter((m) => !m.modifiers_group_id);
+    const defaultStandaloneIds = new Set(
+      newDefaults.filter((d) => !d.modifiers_group_id).map((d) => d.modifier_id)
+    );
+    const preservedStandalone = userStandalone.filter(
+      (m) => !defaultStandaloneIds.has(m.modifier_id)
+    );
+    modifiersModel.value = [...preservedStandalone, ...newDefaults];
+  });
+  return { modifiersModel, selectedModifiersHash, hasAnyModifier };
+}
+function resolveVariantPrice(variant, stockId) {
+  if (variant.prices?.length) {
+    if (stockId) {
+      const stockEntry = variant.prices.find((p) => p.stock_id === stockId);
+      if (stockEntry) {
+        return {
+          price: stockEntry.price,
+          originalPrice: stockEntry.original_price,
+          discount: stockEntry.discount
+        };
+      }
+    }
+    const globalEntry = variant.prices.find((p) => p.stock_id === null);
+    if (globalEntry) {
+      return {
+        price: globalEntry.price,
+        originalPrice: globalEntry.original_price,
+        discount: globalEntry.discount
+      };
+    }
+  }
+  return {
+    price: variant.price,
+    originalPrice: variant.original_price ?? null,
+    discount: variant.discount ?? null
+  };
+}
+function useProductPricing(product, stockId) {
+  const variants = computed(() => product.value.variants ?? []);
+  const currentStockId = computed(() => stockId?.value ?? null);
+  const resolvedPrices = computed(
+    () => variants.value.map((v) => resolveVariantPrice(v, currentStockId.value))
+  );
+  const minRequiredModifiersCost = computed(() => {
+    let total = 0;
+    for (const groupEntry of product.value.modifiers_groups ?? []) {
+      const group = groupEntry.group;
+      for (const modEntry of group.modifiers) {
+        if (modEntry.is_required && modEntry.modifier.price) {
+          total += modEntry.modifier.price * Math.max(modEntry.min_quantity ?? 0, 1);
+        }
+      }
+      if (groupEntry.is_required && group.modifiers.length && !group.modifiers.some((m) => m.is_required)) {
+        const cheapest = group.modifiers.reduce(
+          (min, m) => (m.modifier.price ?? 0) < (min.modifier.price ?? 0) ? m : min
+        );
+        total += (cheapest.modifier.price ?? 0) * Math.max(cheapest.min_quantity ?? 0, 1);
+      }
+    }
+    return total;
+  });
+  const displayPrice = computed(() => {
+    if (!resolvedPrices.value.length) {
+      return 0;
+    }
+    return Math.min(...resolvedPrices.value.map((r) => r.price)) + minRequiredModifiersCost.value;
+  });
+  const originalDisplayPrice = computed(() => {
+    if (!resolvedPrices.value.length) return null;
+    const cheapest = resolvedPrices.value.reduce((min, r) => r.price < min.price ? r : min);
+    let originalVariantPrice = null;
+    if (cheapest.originalPrice && cheapest.originalPrice > cheapest.price) {
+      originalVariantPrice = cheapest.originalPrice;
+    } else if (cheapest.discount && cheapest.discount.difference > 0) {
+      originalVariantPrice = cheapest.price + cheapest.discount.difference;
+    }
+    if (!originalVariantPrice) return null;
+    return originalVariantPrice + minRequiredModifiersCost.value;
+  });
+  const hasDifferentPrices = computed(() => {
+    if (resolvedPrices.value.length <= 1) {
+      return false;
+    }
+    const prices = new Set(resolvedPrices.value.map((r) => r.price));
+    return prices.size > 1;
+  });
+  const needsSelection = computed(() => {
+    if (variants.value.length > 1) {
+      return true;
+    }
+    const mods = product.value.modifiers;
+    const groups = product.value.modifiers_groups;
+    return Array.isArray(mods) && mods.length > 0 || Array.isArray(groups) && groups.length > 0;
+  });
+  return { displayPrice, originalDisplayPrice, hasDifferentPrices, needsSelection };
+}
+function getDefaultOptionsModel(product) {
+  const model = {};
+  if (!product.variants?.length) {
+    return model;
+  }
+  const firstVariant = product.variants.find(
+    (variant) => variant.options && variant.options.length
+  );
+  if (!firstVariant) {
+    return model;
+  }
+  firstVariant.options.forEach((option) => {
+    model[option.id] = option.value.id;
+  });
+  return model;
+}
+function getProductVariantOptionsList(product) {
+  const list = [];
+  if (!product.variants?.length) {
+    return list;
+  }
+  product.variants.forEach((variant) => {
+    if (!variant.options?.length) {
+      return;
+    }
+    variant.options.forEach((option) => {
+      let index = list.findIndex((item) => item.id === option.id);
+      if (index === -1) {
+        index = list.push({
+          id: option.id,
+          name: option.name,
+          values: []
+        });
+        index--;
+      }
+      const valueIndex = list[index].values.findIndex(
+        (value) => value.id === option.value.id
+      );
+      if (valueIndex === -1) {
+        list[index].values.push(option.value);
+      }
+    });
+  });
+  return list;
+}
+function computeDisabledValues(variants, optionsList, optionsModel) {
+  if (!variants.length) return {};
+  const result = {};
+  for (const option of optionsList) {
+    const disabled = /* @__PURE__ */ new Set();
+    for (const value of option.values) {
+      const hasMatch = variants.some((variant) => {
+        if (!variant.options?.length) return false;
+        const variantMap = {};
+        for (const opt of variant.options) {
+          variantMap[opt.id] = opt.value.id;
+        }
+        if (variantMap[option.id] !== value.id) return false;
+        for (const [otherId, selectedId] of Object.entries(optionsModel)) {
+          if (otherId === option.id) continue;
+          if (variantMap[otherId] !== selectedId) return false;
+        }
+        return true;
+      });
+      if (!hasMatch) {
+        disabled.add(value.id);
+      }
+    }
+    result[option.id] = disabled;
+  }
+  return result;
+}
+function useProductVariant(product) {
+  const optionsModel = ref({ ...getDefaultOptionsModel(product.value) });
+  const optionsList = ref([...getProductVariantOptionsList(product.value)]);
+  const selectedVariant = computed(() => {
+    if (!product.value.variants?.length) {
+      return null;
+    } else if (product.value.variants.length === 1 || !Object.keys(optionsModel.value).length) {
+      return product.value.variants[0] ?? null;
+    }
+    return product.value.variants.find((variant) => {
+      if (!variant.options?.length) {
+        return false;
+      }
+      return variant.options.every(
+        (option) => optionsModel.value[option.id] === option.value.id
+      );
+    }) ?? null;
+  });
+  const disabledValues = computed(
+    () => computeDisabledValues(product.value.variants ?? [], optionsList.value, optionsModel.value)
+  );
+  watch(product, () => {
+    optionsModel.value = { ...getDefaultOptionsModel(product.value) };
+    optionsList.value = [...getProductVariantOptionsList(product.value)];
+  });
+  return { optionsModel, optionsList, selectedVariant, disabledValues };
+}
+function usePriceRecalculation({
+  product,
+  selectedVariant,
+  modifiersModel,
+  requiredModifiersGroupIsMissing,
+  selectedModifiersHash
+}) {
+  const sdk = useRuntime().sdk;
+  const profileStore = useStoreProfileStore();
+  const currentStockId = computed(() => profileStore.stock?.id ?? null);
+  const resolvedVariant = computed(() => {
+    if (!selectedVariant.value) return null;
+    return resolveVariantPrice(selectedVariant.value, currentStockId.value);
+  });
+  const modifierPriceMap = computed(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const item of product.value.modifiers ?? []) {
+      if (item.modifier.price) {
+        map.set(item.modifier.id, item.modifier.price);
+      }
+    }
+    for (const group of product.value.modifiers_groups ?? []) {
+      for (const item of group.group.modifiers ?? []) {
+        if (item.modifier.price) {
+          map.set(item.modifier.id, item.modifier.price);
+        }
+      }
+    }
+    return map;
+  });
+  const selectedModifierTotal = computed(
+    () => modifiersModel.value.reduce(
+      (sum, req) => sum + (modifierPriceMap.value.get(req.modifier_id) ?? 0) * req.quantity,
+      0
+    )
+  );
+  const optimisticPrice = computed(() => {
+    if (!resolvedVariant.value) return 0;
+    return resolvedVariant.value.price + selectedModifierTotal.value;
+  });
+  const optimisticOriginalPrice = computed(() => {
+    if (!resolvedVariant.value) return null;
+    const r = resolvedVariant.value;
+    if (r.originalPrice && r.originalPrice > r.price) return r.originalPrice;
+    if (r.discount && r.discount.difference > 0) return r.price + r.discount.difference;
+    return null;
+  });
+  const apiPrice = ref(null);
+  const apiOriginalPrice = ref(null);
+  const priceIsRecalculating = ref(false);
+  let requestId = 0;
+  const price = computed(() => apiPrice.value ?? optimisticPrice.value);
+  const originalPrice = computed(
+    () => apiOriginalPrice.value ?? optimisticOriginalPrice.value
+  );
+  const priceWasModified = computed(() => apiPrice.value !== null);
+  async function recalculatePrice() {
+    if (requiredModifiersGroupIsMissing.value) return;
+    if (!modifiersModel.value.length || !selectedVariant.value) return;
+    const currentRequestId = ++requestId;
+    priceIsRecalculating.value = true;
+    try {
+      const response = await sdk.products.getProductVariantPrice(
+        profileStore.store.id,
+        product.value.id,
+        selectedVariant.value.id,
+        {
+          modifiers: modifiersModel.value,
+          // exactOptionalPropertyTypes: stock_id включаем только если есть
+          ...currentStockId.value ? { stock_id: currentStockId.value } : {}
+        }
+      );
+      if (currentRequestId !== requestId) return;
+      apiPrice.value = response.price;
+      apiOriginalPrice.value = response.original_price;
+      selectedModifiersHash.value = response.modifiers_hash;
+    } catch (e) {
+      console.error("[usePriceRecalculation] price recalculation failed", e);
+    } finally {
+      if (currentRequestId === requestId) {
+        priceIsRecalculating.value = false;
+      }
+    }
+  }
+  const debouncedRecalculate = createDebounce(() => recalculatePrice(), 300);
+  watch(selectedVariant, () => {
+    apiPrice.value = null;
+    apiOriginalPrice.value = null;
+    requestId++;
+    selectedModifiersHash.value = selectedVariant.value?.default_modifiers?.hash ?? null;
+  });
+  watch(
+    modifiersModel,
+    () => {
+      apiPrice.value = null;
+      apiOriginalPrice.value = null;
+      requestId++;
+      if (modifiersModel.value.length && selectedVariant.value) {
+        debouncedRecalculate();
+      } else {
+        selectedModifiersHash.value = selectedVariant.value?.default_modifiers?.hash ?? null;
+      }
+    },
+    { deep: true }
+  );
+  return { price, originalPrice, priceWasModified, priceIsRecalculating };
+}
+function resolveQuantity(minQuantity) {
+  return minQuantity && minQuantity > 0 ? minQuantity : 1;
+}
+function useProductVariantSelector(product) {
+  const { optionsModel, optionsList, selectedVariant, disabledValues } = useProductVariant(product);
+  const { modifiersModel, selectedModifiersHash } = useProductVariantModifiers(selectedVariant);
+  const requiredModifierEntries = computed(() => {
+    const result = [];
+    for (const groupEntry of product.value.modifiers_groups ?? []) {
+      const group = groupEntry.group;
+      const hasIndividualRequired = group.modifiers.some((m) => m.is_required);
+      for (const modEntry of group.modifiers) {
+        if (modEntry.is_required) {
+          result.push({
+            modifier_id: modEntry.modifier.id,
+            modifiers_group_id: group.id,
+            quantity: resolveQuantity(modEntry.min_quantity)
+          });
+        }
+      }
+      if (groupEntry.is_required && !hasIndividualRequired) {
+        const sorted = [...group.modifiers].sort(
+          (a, b) => (a.modifier.price ?? 0) - (b.modifier.price ?? 0)
+        );
+        const cheapest = sorted[0];
+        if (cheapest) {
+          result.push({
+            modifier_id: cheapest.modifier.id,
+            modifiers_group_id: group.id,
+            quantity: resolveQuantity(cheapest.min_quantity)
+          });
+        }
+      }
+    }
+    return result;
+  });
+  function seedRequiredModifiers() {
+    const missing = requiredModifierEntries.value.filter(
+      (req) => !modifiersModel.value.some((m) => m.modifier_id === req.modifier_id)
+    );
+    if (missing.length) {
+      modifiersModel.value = [...modifiersModel.value, ...missing];
+    }
+  }
+  seedRequiredModifiers();
+  watch(selectedVariant, seedRequiredModifiers);
+  const requiredModifiersGroupIsMissing = computed(() => {
+    const requiredGroups = (product.value.modifiers_groups ?? []).filter((group) => group.is_required).map((group) => group.group.id);
+    if (!requiredGroups.length) return false;
+    return requiredGroups.some(
+      (groupId) => !modifiersModel.value.find((m) => m.modifiers_group_id === groupId && m.quantity > 0)
+    );
+  });
+  const { price, originalPrice, priceWasModified, priceIsRecalculating } = usePriceRecalculation({
+    product,
+    selectedVariant,
+    modifiersModel,
+    requiredModifiersGroupIsMissing,
+    selectedModifiersHash
+  });
+  return {
+    optionsModel,
+    optionsList,
+    disabledValues,
+    modifiersModel,
+    selectedVariant,
+    price,
+    originalPrice,
+    priceWasModified,
+    priceIsRecalculating,
+    selectedModifiersHash,
+    requiredModifiersGroupIsMissing
+  };
+}
+
+// src/products/useRelatedProducts.ts
+function canAddDirectly(product) {
+  const variantsCount = product.variants?.length ?? 0;
+  const hasModifiers = (product.modifiers?.length ?? 0) > 0;
+  const hasModifierGroups = (product.modifiers_groups?.length ?? 0) > 0;
+  return variantsCount === 1 && !hasModifiers && !hasModifierGroups;
+}
+var RELATED_PRODUCT_INCLUDES = "variants.prices,modifiers,modifiers_groups";
+var getRelatedProductsState = createRuntimeState(() => ({
+  productInFlight: /* @__PURE__ */ new Map()
+}));
+function useRelatedProducts() {
+  const runtime = useRuntime();
+  const { sdk } = runtime;
+  const { productInFlight } = getRelatedProductsState(runtime);
+  const profileStore = useStoreProfileStore();
+  const authStore = useAuthStore();
+  function getStoreId() {
+    const id = profileStore.store?.id;
+    if (!id) throw new Error("Store is not initialized");
+    return id;
+  }
+  async function fetchForProduct(productId, orderCredentials, signal) {
+    if (signal?.aborted) return [];
+    const key = orderCredentials ? `${productId}:${orderCredentials.id}` : productId;
+    let promise = productInFlight.get(key);
+    if (!promise) {
+      promise = (async () => {
+        try {
+          const storeId = getStoreId();
+          const query = { with: RELATED_PRODUCT_INCLUDES };
+          if (orderCredentials) {
+            query.order_id = orderCredentials.id;
+            query.order_token = orderCredentials.token;
+          }
+          const url = sdk.client.getStoreUrl(
+            storeId,
+            `/products/${productId}/related/products`,
+            query
+          );
+          const response = await sdk.client.request("GET", url, void 0, authStore.token);
+          return response?.data ?? [];
+        } catch (e) {
+          console.warn("[recommendations:product] fetch failed", e);
+          return [];
+        }
+      })().finally(() => productInFlight.delete(key));
+      productInFlight.set(key, promise);
+    }
+    const result = await promise;
+    return signal?.aborted ? [] : result;
+  }
+  async function fetchForOrder(orderId, orderToken, signal) {
+    if (signal?.aborted) return [];
+    try {
+      const storeId = getStoreId();
+      const url = sdk.client.getStoreUrl(storeId, `/orders/${orderId}/related/products`, {
+        token: orderToken,
+        with: RELATED_PRODUCT_INCLUDES
+      });
+      const response = await sdk.client.request("GET", url, void 0, authStore.token);
+      if (signal?.aborted) return [];
+      return response?.data ?? [];
+    } catch (e) {
+      console.warn("[recommendations:order] fetch failed", e);
+      return [];
+    }
+  }
+  return { fetchForProduct, fetchForOrder };
+}
+
+// src/products/findProductInCatalog.ts
+function findProductInCatalog(catalog, shortId) {
+  for (const item of catalog) {
+    if (!item.products.length) continue;
+    const found = item.products.find((p) => p.short_id === shortId);
+    if (found) return { product: found, catalogItem: item };
+  }
+  return null;
+}
+
+export { canAddDirectly, findProductInCatalog, formatWeight, getProductWeight, getVariantWeight, resolveVariantPrice, toGrams, usePriceRecalculation, useProductPricing, useProductVariant, useProductVariantModifiers, useProductVariantSelector, useProductsByCategory, useRelatedProducts };
+//# sourceMappingURL=chunk-IGDDWGS4.js.map
+//# sourceMappingURL=chunk-IGDDWGS4.js.map