@coursebuilder/core/dist/lib/pricing/props-for-commerce.cjs

Core package for Course Builder

"use strict";
"use server";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/lib/pricing/props-for-commerce.ts
var props_for_commerce_exports = {};
__export(props_for_commerce_exports, {
  getCouponForCode: () => getCouponForCode,
  propsForCommerce: () => propsForCommerce,
  validateCoupon: () => validateCoupon
});
module.exports = __toCommonJS(props_for_commerce_exports);
var import_date_fns = require("date-fns");
var validateCoupon = /* @__PURE__ */ __name(async (coupon, productIds = []) => {
  if (!coupon) {
    return {
      isValid: false,
      isRedeemable: false,
      error: "coupon-not-found"
    };
  }
  const isUsedUp = coupon.maxUses > 0 ? coupon.usedCount >= coupon.maxUses : false;
  const isExpired = coupon.expires ? (0, import_date_fns.isBefore)(new Date(coupon.expires), /* @__PURE__ */ new Date()) : false;
  if (coupon.restrictedToProductId && !productIds.includes(coupon.restrictedToProductId)) {
    return {
      isValid: false,
      isRedeemable: false,
      error: "coupon-not-valid-for-product"
    };
  }
  const isValid = !isUsedUp && !isExpired;
  return {
    isExpired,
    isUsedUp,
    isRedeemable: isValid && Number(coupon.percentageDiscount) >= 1 && !coupon.default,
    isValid
  };
}, "validateCoupon");
async function getCouponForCode(code, productIds = [], adapter) {
  if (!code)
    return void 0;
  let couponFromCode = code && await adapter.getCoupon(code);
  if (couponFromCode) {
    if (productIds.length === 0 && couponFromCode.restrictedToProductId && couponFromCode.percentageDiscount === 1) {
      productIds = [
        couponFromCode?.restrictedToProductId
      ];
    }
    const validatedCoupon = await validateCoupon(couponFromCode, productIds);
    return {
      ...couponFromCode,
      ...validatedCoupon
    };
  }
  return void 0;
}
__name(getCouponForCode, "getCouponForCode");
async function propsForCommerce({ query, userId, products, countryCode = "US" }, adapter) {
  const productIds = products.map((product) => product.id);
  const couponFromCode = await getCouponForCode(query.code || query.coupon, productIds, adapter);
  const allowPurchase = true;
  const purchases = userId ? await adapter.getPurchasesForUser(userId) : false;
  const couponIdFromCoupon = query.coupon || couponFromCode?.isValid && couponFromCode.id;
  return {
    ...userId ? {
      userId
    } : {},
    ...couponFromCode && {
      couponFromCode
    },
    ...couponIdFromCoupon && {
      couponIdFromCoupon
    },
    ...purchases && {
      purchases: [
        ...purchases.map((purchase) => {
          return {
            ...purchase,
            totalAmount: (
              // because serializer doesnt handle 0.00
              typeof purchase.totalAmount === "object" ? Number(purchase.totalAmount) : purchase.totalAmount
            )
          };
        })
      ]
    },
    products,
    allowPurchase,
    country: countryCode
  };
}
__name(propsForCommerce, "propsForCommerce");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  getCouponForCode,
  propsForCommerce,
  validateCoupon
});
//# sourceMappingURL=props-for-commerce.cjs.map