@pisell/private-materials 6.6.7 → 6.6.9

package/dist/lib/components/Sales/Cart/index.js

@@ -0,0 +1,439 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.js');
+const require_index = require('../../../businessModel/SalesModel/Sales/index.js');
+const require_serve = require('./serve.js');
+const require_index$1 = require('../Customer/index.js');
+const require_utils = require('../Checkout/utils.js');
+const require_utils$1 = require('./utils.js');
+let dayjs = require("dayjs");
+dayjs = require_rolldown_runtime.__toESM(dayjs);
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+let __pisell_utils = require("@pisell/utils");
+let ahooks = require("ahooks");
+
+//#region src/components/Sales/Cart/index.tsx
+const defaultState = {
+	cartItems: [],
+	currentCartItem: null
+};
+const CartContext = (0, react.createContext)(void 0);
+const CartProvider = ({ children }) => {
+	const { appContext, appUtils, getUserInfo } = require_index$1.useCustomer();
+	const { data, setData, hooks, getCurrentData } = require_index.useSales();
+	const [openCart, setOpen] = (0, react.useState)(false);
+	const checkRef = (0, react.useRef)(null);
+	const cartData = (0, react.useMemo)(() => {
+		return data.cartData || defaultState;
+	}, [data]);
+	const currentCartItem = (0, react.useMemo)(() => {
+		return cartData.currentCartItem;
+	}, [cartData]);
+	/**
+	* @title: 通过holder对购物车中商品进行分类展示
+	* @Author: xiangfeng.xue
+	*/
+	const cartDataHolderList = (0, react.useMemo)(() => {
+		if (!cartData.cartItems?.length) return [];
+		const selectedHolderItems = getCurrentData().holderData?.selectedHolderItems || [];
+		if (selectedHolderItems?.length) {
+			const cartMap = getCurrentData().cartData.cartItems.reduce((map, cartItem) => {
+				if (!map.has(cartItem.holder_id)) map.set(cartItem.holder_id, []);
+				map.get(cartItem.holder_id).push(cartItem);
+				return map;
+			}, /* @__PURE__ */ new Map());
+			const result = selectedHolderItems.map((holderItem) => {
+				return {
+					...holderItem,
+					children: cartMap.get(holderItem.id) || []
+				};
+			});
+			if (cartMap.get(void 0)) result.push({ children: cartMap.get(void 0) });
+			return result;
+		} else return [{ children: cartData.cartItems }];
+	}, [data]);
+	const onOpenCart = () => {
+		setOpen(true);
+	};
+	const onCloseCart = () => {
+		setOpen(false);
+	};
+	const setCartData = (newCartData) => {
+		setData({ cartData: {
+			...getCurrentData().cartData || {},
+			...newCartData
+		} });
+	};
+	const createCartItemOriginData = () => {
+		return {
+			id: 0,
+			number: 1,
+			registration_type: "all",
+			relation_products: [],
+			product: null,
+			holder: null,
+			like_status: "common",
+			relation_type: "form",
+			schedule_id: 0,
+			relation_id: null,
+			start_date: null,
+			start_time: null,
+			select_date: null,
+			end_time: null,
+			end_date: null,
+			sub_type: "days",
+			duration: 0,
+			is_all: false
+		};
+	};
+	const createCartItem = () => {
+		const cartItem = {
+			_id: (0, __pisell_utils.getUniqueId)(),
+			_originData: createCartItemOriginData()
+		};
+		setCurrentCartItem(cartItem);
+		return cartItem;
+	};
+	/**
+	* 从event列表直接创建购物车
+	*/
+	/**
+	* @title:
+	* @description: 从event列表直接创建购物车，没有holder时选择最后一次操作的holder信息
+	* @param {any} eventItem
+	* @return {void}
+	* @Author: xiangfeng.xue
+	* @Date: 2025-01-20 13:00
+	*/
+	const createCartItemFromEvent = (eventItem) => {
+		console.log("eventItem>>>>>>", eventItem);
+		const { resourceData, holderData } = getCurrentData();
+		let cartItem = {
+			_id: (0, __pisell_utils.getUniqueId)(),
+			_originData: createCartItemOriginData(),
+			resourceItem: resourceData?.currentResourceItem,
+			eventItem: { ...eventItem }
+		};
+		const currentHolderItem = getCurrentHolderItem();
+		if (currentHolderItem) cartItem = {
+			...cartItem,
+			holderItem: currentHolderItem
+		};
+		setCurrentCartItem(cartItem);
+		return cartItem;
+	};
+	/**
+	* 使用holder直接创建购物车
+	*/
+	/**
+	* @description: 使用holder直接创建购物车
+	* @param {any} holderItem holder信息
+	* @return {*}
+	* @Author: xiangfeng.xue
+	*/
+	const createCartItemFromHolder = (holderItem) => {
+		const cartItem = {
+			_id: (0, __pisell_utils.getUniqueId)(),
+			_originData: createCartItemOriginData(),
+			resourceItem: data.resourceData?.currentResourceItem,
+			holderItem
+		};
+		setCurrentCartItem(cartItem);
+		return cartItem;
+	};
+	const checkBeforeAddToCartResquest = (0, ahooks.useRequest)(require_serve.checkBeforeAddToCartApi, {
+		manual: true,
+		onSuccess: (res) => {
+			if (res.data?.length) {
+				const isUnavailable = checkCartItemIsUnavailable(res.data, checkRef.current.cartItem);
+				checkRef.current.callback({
+					result: isUnavailable ? false : true,
+					num: isUnavailable ? res.data?.length : 0
+				});
+			} else checkRef.current.callback({ result: true });
+		}
+	});
+	/**
+	* @title: 商品加入购物车前进行校验
+	* @description:
+	* @Author: xiangfeng.xue
+	*/
+	const checkBeforeAddToCart = () => {
+		return new Promise((resolve) => {
+			const _cartData = getCurrentData().cartData;
+			const newCartItem = createCartItemData() || {};
+			const params = require_utils.formatValues({
+				state: { cartData: { cartItems: [..._cartData.cartItems || [], newCartItem] } },
+				platform: appContext?.appHelper?.constants?.platform
+			});
+			checkRef.current = {
+				callback: (res) => {
+					resolve(res);
+					checkRef.current = null;
+				},
+				cartItem: newCartItem
+			};
+			checkBeforeAddToCartResquest.runAsync(params);
+		});
+	};
+	/**
+	* @title: 构建当前商品的完整购物车数据
+	* @description:
+	* @return {*} Object | null
+	* @Author: xiangfeng.xue
+	*/
+	const createCartItemData = () => {
+		const _cartData = getCurrentData().cartData;
+		if (_cartData.currentCartItem) {
+			const { _id, eventItem = {}, holderItem = {} } = _cartData.currentCartItem || {};
+			const eventDetail = eventItem?.eventDetail;
+			const bookingOptionData = eventDetail?.bookingOptionItem?._originData;
+			console.log("eventDetail>>>>>>", eventDetail);
+			const startDateInfo = eventItem?.eventDetail?.selectDate?.startDateInfo;
+			const startTime = startDateInfo?.times?.[0]?.start_at;
+			const endDateInfo = eventItem?.eventDetail?.selectDate?.endDateInfo;
+			const endTime = endDateInfo?.times?.slice(-1)?.[0]?.end_at;
+			const num = 1;
+			const { totalPrice, originTotal, is_charge_tax } = require_utils$1.handleProductInfo(eventDetail, num);
+			const newCartItem = {
+				_id,
+				id: eventItem.id,
+				name: eventItem.title,
+				price: totalPrice,
+				total: totalPrice,
+				origin_total: isNaN(originTotal) || originTotal === 0 ? void 0 : originTotal,
+				num,
+				image: eventItem.image,
+				isShowNote: true,
+				note: "",
+				holder_title: holderItem.name,
+				holder_id: holderItem.id,
+				symbol: appUtils?.getSymbolic(),
+				start_date: startDateInfo?.date || "",
+				start_time: startTime ? (0, dayjs.default)(startTime || "").format("HH:mm") : "",
+				end_date: endDateInfo?.date || "",
+				format: ["HH:mm DD/MM/YYYY", "YYYY-MM-DD HH:mm"],
+				show_time: true,
+				end_time: endTime ? (0, dayjs.default)(endTime || "").format("HH:mm") : "",
+				custom_day_count: eventItem?.eventDetail?.selectDate?.dates?.length || 0,
+				is_charge_tax,
+				_originData: {
+					..._cartData.currentCartItem._originData,
+					product: {
+						num: 1,
+						product_id: bookingOptionData?.id,
+						note: "",
+						product_bundle: [],
+						product_option_item: [],
+						product_variant_id: 0
+					},
+					relation_id: eventItem.id,
+					start_date: startDateInfo?.date || null,
+					start_time: startTime ? (0, dayjs.default)(startTime || "").format("HH:mm") : null,
+					select_date: startDateInfo?.date || null,
+					metadata: {
+						end_date_text: endDateInfo?.date || null,
+						end_time_text: endTime ? (0, dayjs.default)(endTime || "").format("HH:mm") : null
+					},
+					event_unique_identifier: _id
+				},
+				_productDetail: eventDetail.productDetail
+			};
+			newCartItem.deposit = require_utils$1.handleProductDeposit(newCartItem, eventDetail, num);
+			newCartItem._originData = require_utils$1.handleCartItemOrigin(newCartItem, eventDetail);
+			if (holderItem?._originData) newCartItem._originData.holder = {
+				customer_id: getUserInfo()?.id,
+				form_id: holderItem?._originData?.form_id,
+				form_record: holderItem?._originData?.form_record_id ? [holderItem?._originData?.form_record_id] : null
+			};
+			return newCartItem;
+		}
+		return null;
+	};
+	/**
+	* 将商品加入购物车
+	*/
+	const addToCart = () => {
+		const _cartData = getCurrentData().cartData;
+		const newCartItem = createCartItemData();
+		if (_cartData.currentCartItem && newCartItem) setCartData({
+			cartItems: [..._cartData.cartItems || [], newCartItem],
+			currentCartItem: null
+		});
+	};
+	const updateCartItem = (cartItem) => {
+		setCartData({ cartItems: getCurrentData().cartData.cartItems.map((item) => item._id === cartItem._id ? cartItem : item) });
+		return cartItem;
+	};
+	/**
+	* 将holder添加到所有没有holder信息的商品中
+	* @param holderItem any
+	*/
+	const addHolderToCartItem = (holderItem) => {
+		setCartData({ cartItems: getCurrentData().cartData.cartItems.map((item) => {
+			if (!item.holder_id) {
+				item = {
+					...item,
+					holder_title: holderItem.name,
+					holder_id: holderItem.id
+				};
+				item._originData.holder = {
+					customer_id: getUserInfo()?.id,
+					form_id: holderItem?._originData?.form_id,
+					form_record: holderItem?._originData?.form_record_id ? [holderItem?._originData?.form_record_id] : null
+				};
+			}
+			return item;
+		}) });
+	};
+	/**
+	* @description: 给购物车中商品增加备注
+	* @param {CartItem} cartItem
+	* @Author: xiangfeng.xue
+	*/
+	const addNoteToCartItem = (cartItem) => {
+		setCartData({ cartItems: getCurrentData().cartData.cartItems.map((item) => {
+			if (item._id === cartItem._id) {
+				item = {
+					...item,
+					note: cartItem.note
+				};
+				item._originData.product = {
+					...item._originData.product || {},
+					note: cartItem.note
+				};
+			}
+			return item;
+		}) });
+	};
+	const deleteCartItem = (cartItem) => {
+		setCartData({ cartItems: getCurrentData().cartData.cartItems.filter((item) => item._id !== cartItem._id) });
+	};
+	const deleteCartItemByHolder = (holder_id) => {
+		setCartData({ cartItems: getCurrentData().cartData.cartItems.filter((item) => item.holder_id !== holder_id) });
+	};
+	const clickCartItem = (cartItem) => {
+		setCurrentCartItem(cartItem);
+	};
+	const setCurrentCartItem = (cartItem) => {
+		setCartData({ currentCartItem: cartItem });
+	};
+	const updateCurrentCartItem = (cartItem) => {
+		const item = getCurrentData().cartData?.currentCartItem;
+		if (item) setCurrentCartItem({
+			...item,
+			...cartItem
+		});
+	};
+	const clearCurrentCartItem = () => {
+		setCartData({ currentCartItem: null });
+	};
+	const checkHolder = () => {
+		const currentCartItems = getCurrentData().cartData?.cartItems;
+		if (currentCartItems?.length) {
+			if (currentCartItems.find((v) => !v.holder_id) === void 0) return true;
+		}
+		return false;
+	};
+	/**
+	* @description: 获取当前操作中的holder信息
+	* 如果currentHolderItem在selectedHolderItems中找不到，说明该holder已经被删除
+	* 这时取selectedHolderItems中的最后一个，
+	* @return {*}
+	* @Author: xiangfeng.xue
+	*/
+	const getCurrentHolderItem = () => {
+		const { selectedHolderItems, currentHolderItem } = getCurrentData().holderData || {};
+		if (selectedHolderItems?.length) {
+			let newCurrentHolderItem = currentHolderItem;
+			if (selectedHolderItems.find((v) => v.id === currentHolderItem?.id) === void 0) newCurrentHolderItem = selectedHolderItems[selectedHolderItems.length - 1];
+			return newCurrentHolderItem;
+		}
+		return null;
+	};
+	/**
+	* @title: 检测购物车中商品是否是不可用状态
+	* @description: 250210：本期只关注库存的检测结果
+	* @param {any} list
+	* @param {CartItem} item
+	* @return {*} boolean
+	* @Author: xiangfeng.xue
+	*/
+	const checkCartItemIsUnavailable = (list, item) => {
+		const productId = item._originData?.product?.product_id;
+		const relationId = item._originData?.relation_id;
+		const eventUniqueIdentifier = item._originData?.event_unique_identifier;
+		return list.find((res) => {
+			const checkType = ["available_capacity"];
+			if (res.details?.find((v) => checkType.includes?.(v.type || "")) !== void 0) return res.product_id === productId && res.relation_id === relationId && res.event_unique_identifier === eventUniqueIdentifier;
+			return false;
+		}) !== void 0;
+	};
+	/**
+	* @title: 更新购物车中不可用的商品
+	* @discription
+	* @return {void}
+	* @Author: xiangfeng.xue
+	*/
+	const updateDisabledCartItem = (list) => {
+		const currentCartItems = getCurrentData().cartData.cartItems || [];
+		if (list?.length && currentCartItems.length) setCartData({ cartItems: currentCartItems.map((item) => {
+			if (checkCartItemIsUnavailable(list, item)) item.disabled = true;
+			else item.disabled = false;
+			return item;
+		}) });
+	};
+	/**
+	* @description: 获取没有商品信息的holder名称
+	* @return {Array<string>}
+	* @Author: xiangfeng.xue
+	*/
+	const getWithoutCartItemsHolderNames = () => {
+		const list = [];
+		cartDataHolderList?.forEach?.((v) => {
+			if (!v?.children?.length) list.push(v?.name || "");
+		});
+		return list;
+	};
+	const contextValue = {
+		createCartItem,
+		createCartItemFromEvent,
+		createCartItemFromHolder,
+		addToCart,
+		updateCartItem,
+		deleteCartItem,
+		clickCartItem,
+		updateCurrentCartItem,
+		clearCurrentCartItem,
+		currentCartItem,
+		cartData,
+		checkHolder,
+		openCart,
+		onOpenCart,
+		onCloseCart,
+		deleteCartItemByHolder,
+		addHolderToCartItem,
+		cartDataHolderList,
+		addNoteToCartItem,
+		updateDisabledCartItem,
+		getWithoutCartItemsHolderNames,
+		checkBeforeAddToCartResquest,
+		checkBeforeAddToCart
+	};
+	return /* @__PURE__ */ react.default.createElement(CartContext.Provider, { value: contextValue }, children);
+};
+/**
+* 使用步骤管理的Hook
+* @throws {Error} 如果在StepProvider外部使用会抛出错误
+* @returns {StepContextType} 步骤管理上下文
+*/
+const useCart = () => {
+	const context = react.default.useContext(CartContext);
+	if (!context) throw new Error("useCart must be used within a CartProvider");
+	return context;
+};
+var Cart_default = { defaultState };
+
+//#endregion
+exports.CartProvider = CartProvider;
+exports.default = Cart_default;
+exports.useCart = useCart;

package/dist/lib/components/Sales/Cart/serve.js

@@ -0,0 +1,9 @@
+const require_index = require('../../../utils/index.js');
+
+//#region src/components/Sales/Cart/serve.ts
+const checkBeforeAddToCartApi = (data) => {
+	return require_index.request.getRequest().post("/h5/eventbookingv2/order/check-config", data);
+};
+
+//#endregion
+exports.checkBeforeAddToCartApi = checkBeforeAddToCartApi;

package/dist/lib/components/Sales/Cart/utils.js

@@ -0,0 +1,241 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.js');
+let decimal_js = require("decimal.js");
+decimal_js = require_rolldown_runtime.__toESM(decimal_js);
+
+//#region src/components/Sales/Cart/utils.ts
+const handleProductInfo = (eventDetail, num) => {
+	const { productDetail, bookingOptionItem } = eventDetail;
+	const normalProduct = bookingOptionItem?._originData;
+	let totalPrice = Number(normalProduct?.price || "");
+	let originTotal = Number(normalProduct?.original_price || "");
+	let is_charge_tax = normalProduct?.is_charge_tax;
+	if (productDetail) {
+		const { origin, bundle, options, product_variant_id } = productDetail;
+		let variant = null;
+		if (product_variant_id) {
+			variant = origin?.variant?.find((item) => item?.id === product_variant_id);
+			is_charge_tax = variant?.is_charge_tax;
+		}
+		const params = {
+			product: origin,
+			variant,
+			bundle,
+			options,
+			num
+		};
+		totalPrice = getTotalPrice(params);
+		originTotal = getOriginTotalPrice(params);
+	}
+	return {
+		totalPrice,
+		originTotal,
+		is_charge_tax
+	};
+};
+/**
+* 获取商品总价
+* @description 当前总价计算基于商品数量为1
+* @param item 商品
+* @returns 商品总价
+*/
+const getTotalPrice = (params) => {
+	const { product, bundle, options, variant } = params;
+	const num = params.num || 1;
+	let price = Number(product.price);
+	if (variant) price = Number(variant?.price);
+	if (bundle?.length) price = bundle.reduce((accumulator, currentValue) => {
+		return accumulator + Number(currentValue.price) * Number(currentValue.num);
+	}, price);
+	if (options?.length) price = options.reduce((accumulator, currentValue) => {
+		return accumulator + Number(currentValue.price) * Number(currentValue.num);
+	}, price);
+	return price * num;
+};
+/**
+* 获取商品原始总价
+* @description 当前总价计算基于商品数量为1
+* @param item 商品
+* @returns 商品原始总价
+*/
+const getOriginTotalPrice = (params) => {
+	const { product, bundle, options, variant } = params;
+	const num = params?.num || 1;
+	let price = Number(product.original_price);
+	if (variant) price = Number(variant?.original_price);
+	if (isNaN(price) || price === 0) return;
+	if (bundle?.length) price = bundle.reduce((accumulator, currentValue) => {
+		return accumulator + Number(currentValue.price) * Number(currentValue.num);
+	}, price);
+	if (options?.length) price = options.reduce((accumulator, currentValue) => {
+		return accumulator + Number(currentValue.price) * Number(currentValue.num);
+	}, price);
+	return price * num;
+};
+const handleCartItemOrigin = (cartItem, eventDetail) => {
+	const { productDetail } = eventDetail;
+	const originData = cartItem?._originData || {};
+	if (productDetail) {
+		const { bundle, options, product_variant_id } = productDetail;
+		if (!originData.product) originData.product = {};
+		if (product_variant_id) originData.product.product_variant_id = product_variant_id;
+		if (bundle?.length) originData.product.product_bundle = formatBundleToOrigin(bundle);
+		if (options?.length) originData.product.product_option_item = formatOptionsToOrigin(options);
+	}
+	console.log("originData>>>>>>", originData);
+	return originData;
+};
+const formatBundleToOrigin = (bundle) => {
+	if (!bundle?.length) return [];
+	return bundle.map((d) => {
+		return {
+			bundle_group_id: d.group_id,
+			bundle_id: d.id,
+			bundle_product_id: d?._bundle_product_id || d?.product_id,
+			bundle_variant_id: d.bundle_variant_id,
+			num: d.num,
+			extension_id: d.extension_id,
+			extension_type: d.extension_type,
+			option: formatOptionsToOrigin(d.option)
+		};
+	});
+};
+const formatOptionsToOrigin = (options) => {
+	if (!options?.length) return [];
+	return options.map((d) => {
+		return {
+			num: d.num,
+			option_group_item_id: d.product_option_item_id,
+			option_group_id: d.option_group_id
+		};
+	});
+};
+const handleProductDeposit = (cartItem, eventDetail, num) => {
+	const { productDetail, bookingOptionItem } = eventDetail;
+	const normalProduct = bookingOptionItem?._originData;
+	if (!productDetail && normalProduct) {
+		const { custom_deposit_data } = normalProduct;
+		if (custom_deposit_data?.has_deposit == 1) return getProductDeposit({
+			cartItem,
+			product: normalProduct,
+			num
+		});
+		else return null;
+	}
+	if (!productDetail) return null;
+	const { origin, bundle, options, product_variant_id } = productDetail || {};
+	let deposit = null;
+	const product = origin;
+	if (product_variant_id) product.product_variant_id = product_variant_id;
+	if (origin?.custom_deposit_data?.has_deposit == 1) deposit = getProductDeposit({
+		cartItem,
+		product,
+		bundle,
+		options,
+		num
+	});
+	return deposit;
+};
+/**
+* 获取商品定金
+* @description 定金基于商品售价来算，最终乘商品数量
+* 1、如果套餐主商品有定金规则，则定金为：（套餐商品总售价 * 定金百分比 + 定金固定金额）* 商品数量
+* 2、如果套餐主商品没有定金规则，子商品有定金规则，则定金为：（套餐子商品售价 * 套餐子商品定金百分比 + 套餐子商品定金固定金额）* 商品数量，最终将所有子商品定金相加
+* 3、普通商品/单规格商品/组合规则商品，定金规则：（商品总售价 * 定金百分比 + 定金固定金额）* 商品数量
+* @param params 参数
+* @returns 商品定金
+*/
+const getProductDeposit = (params) => {
+	const { cartItem, product, bundle, options } = params;
+	const num = params?.num || 1;
+	if (product?.custom_deposit_data?.has_deposit == 1) {
+		let total = new decimal_js.default(0);
+		const { deposit_fixed, deposit_percentage, deposit_policy_data, self_deposit_policy_ids } = product?.custom_deposit_data || {};
+		const allProtocols = deposit_policy_data || [];
+		let productHasDeposit = false;
+		const protocolIds = [];
+		if (typeof deposit_fixed === "string" && typeof deposit_percentage === "string") {
+			const { depositTotal, result } = calculateProductDeposit({
+				depositData: product?.custom_deposit_data,
+				total: cartItem?.total || 0,
+				num
+			});
+			if (result) {
+				total = depositTotal;
+				protocolIds.push(...self_deposit_policy_ids || []);
+				productHasDeposit = true;
+			}
+		} else {
+			if (product?.product_variant_id) {
+				const variantProduct = product?.variant?.find((item) => item?.id === product?.product_variant_id);
+				if (variantProduct) {
+					const depositData = variantProduct?.custom_deposit_data;
+					const { depositTotal, result } = calculateProductDeposit({
+						depositData,
+						total: cartItem?.total || 0,
+						num
+					});
+					if (result) {
+						total = depositTotal;
+						protocolIds.push(...depositData?.self_deposit_policy_ids || []);
+						productHasDeposit = true;
+					}
+				}
+			}
+			if (bundle?.length) total = bundle.reduce((accumulator, currBundleProduct) => {
+				const depositData = currBundleProduct?.custom_deposit_data;
+				const { depositTotal, result } = calculateProductDeposit({
+					depositData,
+					total: currBundleProduct?.price,
+					num: currBundleProduct?.num || 1
+				});
+				if (result) {
+					protocolIds.push(...depositData?.self_deposit_policy_ids || []);
+					productHasDeposit = true;
+					return accumulator.plus(depositTotal);
+				}
+				return accumulator;
+			}, new decimal_js.default(0));
+		}
+		if (productHasDeposit) {
+			const ids = new Set(protocolIds);
+			const protocols = allProtocols.filter((item) => ids.has(item.id));
+			return {
+				total: total.toNumber(),
+				protocols
+			};
+		}
+		return null;
+	}
+	return null;
+};
+/**
+* 计算商品定金
+* @param params 参数
+* @returns 商品定金
+*/
+const calculateProductDeposit = (params) => {
+	const { depositData, total, num } = params;
+	if (!depositData) return {
+		result: false,
+		depositTotal: new decimal_js.default(0)
+	};
+	const { deposit_fixed, deposit_percentage } = depositData || {};
+	if (typeof deposit_fixed === "string" && typeof deposit_percentage === "string") {
+		const depositFixed = new decimal_js.default(deposit_fixed || 0);
+		const depositPercent = new decimal_js.default(deposit_percentage || 0);
+		const productTotalPrice = new decimal_js.default(total || 0);
+		return {
+			depositTotal: depositFixed.plus(depositPercent.times(productTotalPrice)).times(num),
+			result: true
+		};
+	}
+	return {
+		result: false,
+		depositTotal: new decimal_js.default(0)
+	};
+};
+
+//#endregion
+exports.handleCartItemOrigin = handleCartItemOrigin;
+exports.handleProductDeposit = handleProductDeposit;
+exports.handleProductInfo = handleProductInfo;