@bluecircuit/offer-calculator 2.0.0

package/dist/index.mjs

@@ -0,0 +1,1062 @@
+import { useState, useMemo, useCallback } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+// src/lib/calculator/hooks.ts
+
+// src/lib/calculator/pricing.ts
+function calculateOffer(basePrice, conditionMultiplier, selectedDefects, minimumOffer = 1) {
+  const parsedBasePrice = parseFloat(String(basePrice));
+  const parsedConditionMultiplier = parseFloat(String(conditionMultiplier));
+  const parsedMinimumOffer = parseFloat(String(minimumOffer));
+  if (isNaN(parsedBasePrice) || parsedBasePrice <= 0 || !isFinite(parsedBasePrice)) {
+    console.error(
+      "[calculateOffer] Invalid base price:",
+      basePrice,
+      "| Returning minimum offer"
+    );
+    return createMinimumOfferResult(
+      basePrice,
+      parsedConditionMultiplier || 1,
+      selectedDefects,
+      parsedMinimumOffer
+    );
+  }
+  const validConditionMultiplier = isNaN(parsedConditionMultiplier) || !isFinite(parsedConditionMultiplier) || parsedConditionMultiplier <= 0 ? 1 : parsedConditionMultiplier;
+  const validMinimumOffer = isNaN(parsedMinimumOffer) || !isFinite(parsedMinimumOffer) || parsedMinimumOffer <= 0 ? 1 : parsedMinimumOffer;
+  let price = parsedBasePrice * validConditionMultiplier;
+  const priceAfterCondition = price;
+  const validDefects = selectedDefects.filter((d) => {
+    const percent = parseFloat(String(d.percent));
+    if (isNaN(percent) || !isFinite(percent) || percent < 0 || percent > 100) {
+      console.warn("[calculateOffer] Invalid defect percent:", d);
+      return false;
+    }
+    return true;
+  });
+  const sortedDefects = [...validDefects].sort(
+    (a, b) => b.percent - a.percent
+  );
+  for (const defect of sortedDefects) {
+    const discountMultiplier = 1 - defect.percent / 100;
+    price = price * discountMultiplier;
+  }
+  const priceBeforeClamp = Math.round(price * 100) / 100;
+  const finalPrice = Math.max(validMinimumOffer, priceBeforeClamp);
+  const minimumEnforced = finalPrice === validMinimumOffer && priceBeforeClamp < validMinimumOffer;
+  if (minimumEnforced) {
+    console.warn(
+      `[calculateOffer] Minimum price enforced: $${priceBeforeClamp.toFixed(2)} \u2192 $${finalPrice.toFixed(2)}`
+    );
+  }
+  const totalDiscountPercent = sortedDefects.reduce(
+    (sum, defect) => sum + defect.percent,
+    0
+  );
+  const breakdown = {
+    basePrice: parsedBasePrice,
+    conditionMultiplier: validConditionMultiplier,
+    priceAfterCondition,
+    appliedDefects: sortedDefects,
+    totalDiscountPercent,
+    priceBeforeClamp,
+    minimumEnforced
+  };
+  return {
+    finalPrice,
+    breakdown
+  };
+}
+function createMinimumOfferResult(basePrice, conditionMultiplier, _selectedDefects, minimumOffer) {
+  return {
+    finalPrice: minimumOffer,
+    breakdown: {
+      basePrice: parseFloat(String(basePrice)) || 0,
+      conditionMultiplier: conditionMultiplier || 1,
+      priceAfterCondition: 0,
+      appliedDefects: [],
+      totalDiscountPercent: 0,
+      priceBeforeClamp: 0,
+      minimumEnforced: true
+    }
+  };
+}
+function formatCurrency(price, currency = "USD", locale = "en-US") {
+  try {
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency,
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2
+    }).format(price);
+  } catch (error) {
+    console.error("[formatCurrency] Error formatting:", error);
+    return `$${price.toFixed(2)}`;
+  }
+}
+function calculateEffectiveDiscount(selectedDefects) {
+  let multiplier = 1;
+  for (const defect of selectedDefects) {
+    const discountMultiplier = 1 - defect.percent / 100;
+    multiplier *= discountMultiplier;
+  }
+  const effectiveDiscount = (1 - multiplier) * 100;
+  return Math.round(effectiveDiscount * 100) / 100;
+}
+
+// src/lib/calculator/hooks.ts
+function useOfferCalculator(config) {
+  const [selectedDefectIds, setSelectedDefectIds] = useState(
+    /* @__PURE__ */ new Set()
+  );
+  const [selectedConditionId, setSelectedConditionId] = useState(() => {
+    const defaultCondition = config.conditions.find((c) => c.isDefault);
+    return defaultCondition?.id || config.conditions[0]?.id || "";
+  });
+  const [hasDefects, setHasDefects] = useState(false);
+  const selectedDefects = useMemo(() => {
+    return config.defects.filter((defect) => selectedDefectIds.has(defect.id));
+  }, [config.defects, selectedDefectIds]);
+  const currentCondition = useMemo(() => {
+    const found = config.conditions.find((c) => c.id === selectedConditionId);
+    if (found) return found;
+    const firstCondition = config.conditions[0];
+    if (!firstCondition) {
+      return {
+        id: "default",
+        label: "Default",
+        percent: 100,
+        multiplier: 1,
+        description: "Default condition",
+        isDefault: true
+      };
+    }
+    return firstCondition;
+  }, [config.conditions, selectedConditionId]);
+  const calculationResult = useMemo(() => {
+    return calculateOffer(
+      config.basePrice,
+      currentCondition.multiplier,
+      selectedDefects,
+      config.minimumOffer
+    );
+  }, [
+    config.basePrice,
+    config.minimumOffer,
+    currentCondition.multiplier,
+    selectedDefects
+  ]);
+  const toggleDefect = useCallback((defectId) => {
+    setSelectedDefectIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(defectId)) {
+        next.delete(defectId);
+      } else {
+        next.add(defectId);
+      }
+      return next;
+    });
+  }, []);
+  const selectCondition = useCallback((conditionId) => {
+    setSelectedConditionId(conditionId);
+    setSelectedDefectIds(/* @__PURE__ */ new Set());
+    setHasDefects(false);
+  }, []);
+  const toggleHasDefects = useCallback(() => {
+    setHasDefects((prev) => {
+      const newValue = !prev;
+      if (!newValue) {
+        setSelectedDefectIds(/* @__PURE__ */ new Set());
+      }
+      return newValue;
+    });
+  }, []);
+  const clearDefects = useCallback(() => {
+    setSelectedDefectIds(/* @__PURE__ */ new Set());
+  }, []);
+  return {
+    // State
+    selectedDefectIds,
+    selectedConditionId,
+    hasDefects,
+    // Handlers
+    toggleDefect,
+    selectCondition,
+    toggleHasDefects,
+    clearDefects,
+    // Derived values
+    calculationResult,
+    selectedDefects,
+    currentCondition
+  };
+}
+function useDefectCheckbox(defectId, isSelected, onToggle) {
+  const handleChange = useCallback(() => {
+    onToggle(defectId);
+  }, [defectId, onToggle]);
+  return {
+    checked: isSelected,
+    handleChange
+  };
+}
+function ConditionTabs({
+  conditions,
+  selectedConditionId,
+  onSelectCondition,
+  className = ""
+}) {
+  const handleKeyDown = useCallback(
+    (event, currentIndex) => {
+      let newIndex = currentIndex;
+      switch (event.key) {
+        case "ArrowRight":
+        case "ArrowDown":
+          event.preventDefault();
+          newIndex = (currentIndex + 1) % conditions.length;
+          break;
+        case "ArrowLeft":
+        case "ArrowUp":
+          event.preventDefault();
+          newIndex = currentIndex === 0 ? conditions.length - 1 : currentIndex - 1;
+          break;
+        case "Home":
+          event.preventDefault();
+          newIndex = 0;
+          break;
+        case "End":
+          event.preventDefault();
+          newIndex = conditions.length - 1;
+          break;
+        default:
+          return;
+      }
+      const nextCondition = conditions[newIndex];
+      if (nextCondition) {
+        onSelectCondition(nextCondition.id);
+      }
+    },
+    [conditions, onSelectCondition]
+  );
+  return /* @__PURE__ */ jsxs("div", { className: `condition-tabs ${className}`, children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        role: "tablist",
+        "aria-label": "Device condition",
+        className: "condition-tabs__list",
+        children: conditions.map((condition, index) => {
+          const isSelected = condition.id === selectedConditionId;
+          return /* @__PURE__ */ jsxs(
+            "button",
+            {
+              role: "tab",
+              "aria-selected": isSelected,
+              "aria-controls": `condition-panel-${condition.id}`,
+              id: `condition-tab-${condition.id}`,
+              tabIndex: isSelected ? 0 : -1,
+              onClick: () => onSelectCondition(condition.id),
+              onKeyDown: (e) => handleKeyDown(e, index),
+              className: `condition-tabs__tab ${isSelected ? "condition-tabs__tab--active" : ""}`,
+              title: condition.description,
+              children: [
+                /* @__PURE__ */ jsx("span", { className: "condition-tabs__tab-label", children: condition.label }),
+                /* @__PURE__ */ jsxs("span", { className: "condition-tabs__tab-multiplier", children: [
+                  condition.percent,
+                  "%"
+                ] })
+              ]
+            },
+            condition.id
+          );
+        })
+      }
+    ),
+    conditions.map((condition) => {
+      const isSelected = condition.id === selectedConditionId;
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          role: "tabpanel",
+          id: `condition-panel-${condition.id}`,
+          "aria-labelledby": `condition-tab-${condition.id}`,
+          hidden: !isSelected,
+          className: "condition-tabs__panel",
+          children: /* @__PURE__ */ jsx("p", { className: "condition-tabs__description", children: condition.description })
+        },
+        condition.id
+      );
+    })
+  ] });
+}
+function CompactConditionSelector({
+  conditions,
+  selectedConditionId,
+  onSelectCondition,
+  className = ""
+}) {
+  const handleChange = (event) => {
+    onSelectCondition(event.target.value);
+  };
+  const selectedCondition = conditions.find(
+    (c) => c.id === selectedConditionId
+  );
+  return /* @__PURE__ */ jsxs("div", { className: `condition-selector ${className}`, children: [
+    /* @__PURE__ */ jsx("label", { htmlFor: "condition-select", className: "condition-selector__label", children: "Device Condition:" }),
+    /* @__PURE__ */ jsx(
+      "select",
+      {
+        id: "condition-select",
+        value: selectedConditionId,
+        onChange: handleChange,
+        className: "condition-selector__select",
+        "aria-describedby": "condition-description",
+        children: conditions.map((condition) => /* @__PURE__ */ jsxs("option", { value: condition.id, children: [
+          condition.label,
+          " (",
+          condition.percent,
+          "%)"
+        ] }, condition.id))
+      }
+    ),
+    selectedCondition && /* @__PURE__ */ jsx(
+      "p",
+      {
+        id: "condition-description",
+        className: "condition-selector__description",
+        children: selectedCondition.description
+      }
+    )
+  ] });
+}
+function DefectCheckbox({
+  defect,
+  isSelected,
+  onToggle,
+  disabled = false,
+  className = ""
+}) {
+  const { checked, handleChange } = useDefectCheckbox(
+    defect.id,
+    isSelected,
+    onToggle
+  );
+  const [tooltipVisible, setTooltipVisible] = useState(false);
+  const checkboxId = `defect-${defect.id}`;
+  const tooltipId = defect.description ? `defect-tooltip-${defect.id}` : void 0;
+  return /* @__PURE__ */ jsxs("div", { className: `defect-checkbox ${className}`, children: [
+    /* @__PURE__ */ jsxs(
+      "label",
+      {
+        htmlFor: checkboxId,
+        className: "defect-checkbox__label",
+        onMouseEnter: () => setTooltipVisible(true),
+        onMouseLeave: () => setTooltipVisible(false),
+        onFocus: () => setTooltipVisible(true),
+        onBlur: () => setTooltipVisible(false),
+        children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "checkbox",
+              id: checkboxId,
+              checked,
+              onChange: handleChange,
+              disabled,
+              "aria-describedby": tooltipId,
+              className: "defect-checkbox__input"
+            }
+          ),
+          /* @__PURE__ */ jsxs("span", { className: "defect-checkbox__text", children: [
+            defect.label,
+            /* @__PURE__ */ jsxs("span", { className: "defect-checkbox__percent", children: [
+              " ",
+              "(",
+              defect.percent,
+              "% off)"
+            ] })
+          ] }),
+          defect.description && /* @__PURE__ */ jsx("span", { className: "defect-checkbox__info-icon", "aria-hidden": "true", children: "\u2139\uFE0F" })
+        ]
+      }
+    ),
+    defect.description && tooltipVisible && /* @__PURE__ */ jsx(
+      "div",
+      {
+        id: tooltipId,
+        role: "tooltip",
+        className: "defect-checkbox__tooltip",
+        "aria-hidden": !tooltipVisible,
+        children: defect.description
+      }
+    )
+  ] });
+}
+function DefectCheckboxList({
+  defects,
+  selectedDefectIds,
+  onToggle,
+  disabled = false,
+  groupByCategory = false,
+  className = ""
+}) {
+  if (!groupByCategory) {
+    return /* @__PURE__ */ jsx("div", { className: `defect-checkbox-list ${className}`, children: defects.map((defect) => /* @__PURE__ */ jsx(
+      DefectCheckbox,
+      {
+        defect,
+        isSelected: selectedDefectIds.has(defect.id),
+        onToggle,
+        disabled
+      },
+      defect.id
+    )) });
+  }
+  const grouped = defects.reduce(
+    (acc, defect) => {
+      const category = defect.category || "other";
+      if (!acc[category]) {
+        acc[category] = [];
+      }
+      acc[category].push(defect);
+      return acc;
+    },
+    {}
+  );
+  return /* @__PURE__ */ jsx("div", { className: `defect-checkbox-list defect-checkbox-list--grouped ${className}`, children: Object.entries(grouped).map(([category, categoryDefects]) => /* @__PURE__ */ jsxs("div", { className: "defect-checkbox-list__group", children: [
+    /* @__PURE__ */ jsx("h4", { className: "defect-checkbox-list__group-title", children: category.charAt(0).toUpperCase() + category.slice(1) }),
+    categoryDefects.map((defect) => /* @__PURE__ */ jsx(
+      DefectCheckbox,
+      {
+        defect,
+        isSelected: selectedDefectIds.has(defect.id),
+        onToggle,
+        disabled
+      },
+      defect.id
+    ))
+  ] }, category)) });
+}
+function PriceDisplay({
+  result,
+  currency = "USD",
+  locale = "en-US",
+  showBreakdown = false,
+  className = ""
+}) {
+  const { finalPrice, breakdown } = result;
+  const formattedPrice = formatCurrency(finalPrice, currency, locale);
+  return /* @__PURE__ */ jsxs("div", { className: `price-display ${className}`, children: [
+    /* @__PURE__ */ jsxs("div", { className: "price-display__main", children: [
+      /* @__PURE__ */ jsx("span", { className: "price-display__label", children: "Your Offer:" }),
+      /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: "price-display__value",
+          "aria-live": "polite",
+          "aria-atomic": "true",
+          children: formattedPrice
+        }
+      )
+    ] }),
+    breakdown.minimumEnforced && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "price-display__warning",
+        role: "alert",
+        "aria-live": "assertive",
+        children: [
+          "\u26A0\uFE0F Minimum offer of ",
+          formatCurrency(finalPrice, currency, locale),
+          " ",
+          "enforced"
+        ]
+      }
+    ),
+    showBreakdown && /* @__PURE__ */ jsxs("div", { className: "price-display__breakdown", children: [
+      /* @__PURE__ */ jsx("h4", { children: "Calculation Breakdown" }),
+      /* @__PURE__ */ jsxs("dl", { className: "price-display__breakdown-list", children: [
+        /* @__PURE__ */ jsx("dt", { children: "Base Price:" }),
+        /* @__PURE__ */ jsx("dd", { children: formatCurrency(breakdown.basePrice, currency, locale) }),
+        /* @__PURE__ */ jsx("dt", { children: "Condition Multiplier:" }),
+        /* @__PURE__ */ jsxs("dd", { children: [
+          breakdown.conditionMultiplier.toFixed(2),
+          "x"
+        ] }),
+        /* @__PURE__ */ jsx("dt", { children: "Price After Condition:" }),
+        /* @__PURE__ */ jsx("dd", { children: formatCurrency(breakdown.priceAfterCondition, currency, locale) }),
+        breakdown.appliedDefects.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx("dt", { children: "Applied Defects:" }),
+          /* @__PURE__ */ jsx("dd", { children: /* @__PURE__ */ jsx("ul", { children: breakdown.appliedDefects.map((defect) => /* @__PURE__ */ jsxs("li", { children: [
+            defect.label,
+            " (",
+            defect.percent,
+            "%)"
+          ] }, defect.id)) }) }),
+          /* @__PURE__ */ jsx("dt", { children: "Total Discount (additive):" }),
+          /* @__PURE__ */ jsxs("dd", { children: [
+            breakdown.totalDiscountPercent.toFixed(2),
+            "%"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx("dt", { children: "Price Before Minimum:" }),
+        /* @__PURE__ */ jsx("dd", { children: formatCurrency(breakdown.priceBeforeClamp, currency, locale) }),
+        /* @__PURE__ */ jsx("dt", { children: "Final Offer:" }),
+        /* @__PURE__ */ jsx("dd", { children: /* @__PURE__ */ jsx("strong", { children: formattedPrice }) })
+      ] })
+    ] })
+  ] });
+}
+function CompactPriceDisplay({
+  result,
+  currency = "USD",
+  locale = "en-US",
+  className = ""
+}) {
+  const formattedPrice = formatCurrency(result.finalPrice, currency, locale);
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: `price-display--compact ${className}`,
+      "aria-live": "polite",
+      "aria-atomic": "true",
+      children: formattedPrice
+    }
+  );
+}
+
+// src/components/calculator/calculator.module.css
+var calculator_default = {};
+function OfferCalculator({
+  config,
+  showBreakdown = false,
+  className = "",
+  formFieldPrefix = ""
+}) {
+  const {
+    selectedDefectIds,
+    selectedConditionId,
+    hasDefects,
+    toggleDefect,
+    selectCondition,
+    toggleHasDefects,
+    calculationResult,
+    currentCondition
+  } = useOfferCalculator(config);
+  return /* @__PURE__ */ jsxs("div", { className: `${calculator_default.calculator} ${className}`, children: [
+    /* @__PURE__ */ jsxs("div", { className: calculator_default.calculator__header, children: [
+      /* @__PURE__ */ jsxs("h2", { className: calculator_default.calculator__title, children: [
+        "Get an Offer for Your ",
+        config.device.model
+      ] }),
+      /* @__PURE__ */ jsx("p", { className: calculator_default.calculator__subtitle, children: "Select your device condition and any defects to see your offer." })
+    ] }),
+    /* @__PURE__ */ jsxs("section", { className: calculator_default.calculator__section, children: [
+      /* @__PURE__ */ jsx("h3", { className: calculator_default.calculator__sectionTitle, children: "1. Select Device Condition" }),
+      /* @__PURE__ */ jsx(
+        ConditionTabs,
+        {
+          conditions: config.conditions,
+          selectedConditionId,
+          onSelectCondition: selectCondition
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("section", { className: calculator_default.calculator__section, children: [
+      /* @__PURE__ */ jsx("h3", { className: calculator_default.calculator__sectionTitle, children: "2. Does Your Device Have Any Defects?" }),
+      /* @__PURE__ */ jsxs("div", { className: calculator_default.calculator__defectsToggle, children: [
+        /* @__PURE__ */ jsxs("label", { className: calculator_default.calculator__radioLabel, children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "radio",
+              name: "has_defects",
+              value: "no",
+              checked: !hasDefects,
+              onChange: () => {
+                if (hasDefects) toggleHasDefects();
+              },
+              className: calculator_default.calculator__radioInput
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { children: "No defects" })
+        ] }),
+        /* @__PURE__ */ jsxs("label", { className: calculator_default.calculator__radioLabel, children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "radio",
+              name: "has_defects",
+              value: "yes",
+              checked: hasDefects,
+              onChange: () => {
+                if (!hasDefects) toggleHasDefects();
+              },
+              className: calculator_default.calculator__radioInput
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { children: "Yes, has defects" })
+        ] })
+      ] })
+    ] }),
+    hasDefects && config.defects.length > 0 && /* @__PURE__ */ jsxs(
+      "section",
+      {
+        className: calculator_default.calculator__section,
+        "data-testid": "defects-section",
+        children: [
+          /* @__PURE__ */ jsx("h3", { className: calculator_default.calculator__sectionTitle, children: "3. Select All Defects" }),
+          /* @__PURE__ */ jsx("p", { className: calculator_default.calculator__hint, children: "Select all that apply. Order doesn't matter." }),
+          /* @__PURE__ */ jsx(
+            DefectCheckboxList,
+            {
+              defects: config.defects,
+              selectedDefectIds,
+              onToggle: toggleDefect,
+              groupByCategory: false
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx("section", { className: calculator_default.calculator__section, children: /* @__PURE__ */ jsx(
+      PriceDisplay,
+      {
+        result: calculationResult,
+        currency: config.currency,
+        showBreakdown
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      HiddenFormInputs,
+      {
+        finalPrice: calculationResult.finalPrice,
+        conditionId: currentCondition.id,
+        selectedDefectIds: Array.from(selectedDefectIds),
+        deviceId: String(config.device.id),
+        fieldPrefix: formFieldPrefix
+      }
+    )
+  ] });
+}
+function HiddenFormInputs({
+  finalPrice,
+  conditionId,
+  selectedDefectIds,
+  deviceId,
+  fieldPrefix = ""
+}) {
+  const prefix = fieldPrefix ? `${fieldPrefix}_` : "";
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "hidden",
+        name: `${prefix}device_price`,
+        value: finalPrice.toFixed(2)
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "hidden",
+        name: `${prefix}gadget_cosmetic_condition`,
+        value: conditionId
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "hidden",
+        name: `${prefix}selected_defects`,
+        value: JSON.stringify(selectedDefectIds)
+      }
+    ),
+    /* @__PURE__ */ jsx("input", { type: "hidden", name: `${prefix}device_id`, value: deviceId })
+  ] });
+}
+function CalculatorErrorBoundary({
+  error,
+  reset
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: calculator_default.calculator__error, children: [
+    /* @__PURE__ */ jsx("h2", { children: "Calculator Error" }),
+    /* @__PURE__ */ jsx("p", { children: "We're sorry, but the calculator encountered an error. Please try again or contact support." }),
+    reset && /* @__PURE__ */ jsx("button", { onClick: reset, className: calculator_default.calculator__errorButton, children: "Try Again" }),
+    process.env.NODE_ENV === "development" && /* @__PURE__ */ jsxs("details", { className: calculator_default.calculator__errorDetails, children: [
+      /* @__PURE__ */ jsx("summary", { children: "Error Details (dev only)" }),
+      /* @__PURE__ */ jsx("pre", { children: error.message }),
+      /* @__PURE__ */ jsx("pre", { children: error.stack })
+    ] })
+  ] });
+}
+
+// src/lib/calculator/validation.ts
+function normalizeConfig(raw) {
+  const basePrice = parseFloat(raw?.basePrice);
+  const validBasePrice = !isNaN(basePrice) && isFinite(basePrice) && basePrice > 0 ? basePrice : 1;
+  const currency = typeof raw?.currency === "string" && raw.currency.length > 0 ? raw.currency : "USD";
+  const defects = normalizeDefects(raw?.defects);
+  const conditions = normalizeConditions(raw?.conditions);
+  const device = normalizeDeviceInfo(raw?.device);
+  const minimumOffer = parseFloat(raw?.minimumOffer);
+  const validMinimumOffer = !isNaN(minimumOffer) && isFinite(minimumOffer) && minimumOffer > 0 ? minimumOffer : 1;
+  return {
+    basePrice: validBasePrice,
+    currency,
+    defects,
+    conditions,
+    device,
+    minimumOffer: validMinimumOffer
+  };
+}
+function normalizeDefects(raw) {
+  if (!Array.isArray(raw)) {
+    console.warn("[normalizeConfig] Defects is not an array:", raw);
+    return [];
+  }
+  return raw.filter((item) => {
+    if (!item?.id || typeof item.label !== "string") {
+      console.warn("[normalizeConfig] Invalid defect (missing id/label):", item);
+      return false;
+    }
+    return true;
+  }).map((item) => {
+    const percent = parseFloat(item.percent);
+    const validPercent = !isNaN(percent) && isFinite(percent) ? Math.max(0, Math.min(100, percent)) : 0;
+    const defect = {
+      id: String(item.id),
+      label: String(item.label),
+      percent: validPercent
+    };
+    if (item.description) {
+      defect.description = String(item.description);
+    }
+    if (item.category) {
+      defect.category = String(item.category);
+    }
+    return defect;
+  });
+}
+function normalizeConditions(raw) {
+  if (!Array.isArray(raw)) {
+    console.warn("[normalizeConfig] Conditions is not an array:", raw);
+    return createDefaultConditions();
+  }
+  const normalized = raw.filter((item) => {
+    if (!item?.id || !item?.label) {
+      console.warn("[normalizeConfig] Invalid condition (missing id/label):", item);
+      return false;
+    }
+    return true;
+  }).map((item) => {
+    const percent = parseFloat(item.percent);
+    const validPercent = !isNaN(percent) && isFinite(percent) && percent > 0 ? percent : 100;
+    const multiplier = validPercent / 100;
+    const condition = {
+      id: String(item.id),
+      label: String(item.label),
+      percent: validPercent,
+      multiplier,
+      description: item.description ? String(item.description) : ""
+    };
+    if (item.isDefault) {
+      condition.isDefault = true;
+    }
+    return condition;
+  });
+  if (normalized.length === 0) {
+    return createDefaultConditions();
+  }
+  return normalized;
+}
+function createDefaultConditions() {
+  return [
+    {
+      id: "flawless",
+      label: "Flawless",
+      percent: 100,
+      multiplier: 1,
+      description: "Like New, no visible signs of previous usage.",
+      isDefault: true
+    }
+  ];
+}
+function normalizeDeviceInfo(raw) {
+  return {
+    id: raw?.id !== void 0 ? String(raw.id) : "unknown",
+    model: raw?.model ? String(raw.model) : "Unknown Device",
+    type: raw?.type ? String(raw.type) : "device"
+  };
+}
+function validateConfig(config) {
+  const errors = [];
+  if (config.basePrice <= 0) {
+    errors.push({
+      field: "basePrice",
+      message: "Base price must be positive",
+      severity: "error"
+    });
+  }
+  if (config.minimumOffer <= 0) {
+    errors.push({
+      field: "minimumOffer",
+      message: "Minimum offer must be positive",
+      severity: "error"
+    });
+  }
+  if (config.defects.length === 0) {
+    errors.push({
+      field: "defects",
+      message: "No defects configured",
+      severity: "warning"
+    });
+  }
+  if (config.conditions.length === 0) {
+    errors.push({
+      field: "conditions",
+      message: "No conditions configured",
+      severity: "error"
+    });
+  }
+  const defectIds = /* @__PURE__ */ new Set();
+  for (const defect of config.defects) {
+    if (defectIds.has(defect.id)) {
+      errors.push({
+        field: "defects",
+        message: `Duplicate defect ID: ${defect.id}`,
+        severity: "error"
+      });
+    }
+    defectIds.add(defect.id);
+  }
+  const conditionIds = /* @__PURE__ */ new Set();
+  for (const condition of config.conditions) {
+    if (conditionIds.has(condition.id)) {
+      errors.push({
+        field: "conditions",
+        message: `Duplicate condition ID: ${condition.id}`,
+        severity: "error"
+      });
+    }
+    conditionIds.add(condition.id);
+  }
+  const hasDefault = config.conditions.some((c) => c.isDefault);
+  if (!hasDefault && config.conditions.length > 0) {
+    errors.push({
+      field: "conditions",
+      message: "No condition marked as default",
+      severity: "warning"
+    });
+  }
+  return errors;
+}
+function hasErrors(errors) {
+  return errors.some((e) => e.severity === "error");
+}
+function formatValidationErrors(errors) {
+  if (errors.length === 0) {
+    return "";
+  }
+  return errors.map((error) => {
+    const prefix = error.severity === "error" ? "\u274C" : "\u26A0\uFE0F";
+    return `${prefix} ${error.field}: ${error.message}`;
+  }).join("\n");
+}
+
+// src/lib/cms/fetchCalculatorConfig.ts
+async function fetchCalculatorConfig(deviceId) {
+  const apiUrl = process.env.CALCULATOR_API_URL || "/api/calculator/config";
+  const url = `${apiUrl}?deviceId=${encodeURIComponent(deviceId)}`;
+  try {
+    const response = await fetch(url, {
+      next: {
+        revalidate: 3600,
+        // Cache for 1 hour
+        tags: [`calculator-config-${deviceId}`]
+        // For on-demand revalidation
+      }
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch calculator config: ${response.status} ${response.statusText}`
+      );
+    }
+    const rawData = await response.json();
+    const config = normalizeConfig(rawData);
+    const validationErrors = validateConfig(config);
+    const warnings = validationErrors.filter((e) => e.severity === "warning");
+    if (warnings.length > 0) {
+      console.warn(
+        "[fetchCalculatorConfig] Validation warnings:",
+        formatValidationErrors(warnings)
+      );
+    }
+    if (hasErrors(validationErrors)) {
+      const errorMessage = formatValidationErrors(
+        validationErrors.filter((e) => e.severity === "error")
+      );
+      throw new Error(
+        `Calculator config validation failed:
+${errorMessage}`
+      );
+    }
+    return config;
+  } catch (error) {
+    console.error("[fetchCalculatorConfig] Error fetching config:", error);
+    throw new Error(
+      `Failed to load calculator configuration for device ${deviceId}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function getMockCalculatorConfig(deviceId) {
+  return {
+    basePrice: 230,
+    currency: "USD",
+    defects: [
+      {
+        id: "check1",
+        label: "Motherboard issues/Doesn't power on",
+        percent: 60,
+        description: "Select if device has defective MB, BIOS locked, or won't boot. Major discount.",
+        category: "critical"
+      },
+      {
+        id: "check2",
+        label: "Cracked/broken screen",
+        percent: 45,
+        description: "Select if screen has cracks, dead pixels, or display issues.",
+        category: "critical"
+      },
+      {
+        id: "check3",
+        label: "Hard drive missing/defective",
+        percent: 15,
+        description: "Select if HDD/SSD is missing or not working.",
+        category: "hardware"
+      },
+      {
+        id: "check5",
+        label: "Charger/adapter missing",
+        percent: 15,
+        description: "Select if power adapter is not included.",
+        category: "accessories"
+      },
+      {
+        id: "check6",
+        label: "Battery issues",
+        percent: 15,
+        description: "Select if battery doesn't hold charge or is swollen.",
+        category: "hardware"
+      },
+      {
+        id: "check7",
+        label: "Keyboard/touchpad issues",
+        percent: 20,
+        description: "Select if keys are missing or input devices not working.",
+        category: "hardware"
+      },
+      {
+        id: "check11",
+        label: "CPU/processor issues",
+        percent: 30,
+        description: "Select if CPU is defective or underperforming.",
+        category: "hardware"
+      },
+      {
+        id: "check13",
+        label: "RAM issues",
+        percent: 15,
+        description: "Select if memory is defective or missing.",
+        category: "hardware"
+      },
+      {
+        id: "check16",
+        label: "Damaged housing/case",
+        percent: 30,
+        description: "Select if case has major dents, cracks, or damage.",
+        category: "cosmetic"
+      },
+      {
+        id: "check20",
+        label: "Graphics card issues",
+        percent: 45,
+        description: "Select if GPU is defective or has display artifacts.",
+        category: "hardware"
+      },
+      {
+        id: "check4",
+        label: "Optical drive missing/defective",
+        percent: 15,
+        description: "Select if CD/DVD drive is missing or not working.",
+        category: "hardware"
+      },
+      {
+        id: "check9",
+        label: "Overheating issues",
+        percent: 30,
+        description: "Select if device overheats or fan doesn't work.",
+        category: "hardware"
+      },
+      {
+        id: "check12",
+        label: "BIOS password locked",
+        percent: 70,
+        description: "Select if device has BIOS password and cannot be reset. Major discount.",
+        category: "critical"
+      }
+    ],
+    conditions: [
+      {
+        id: "flawless",
+        label: "Flawless",
+        percent: 100,
+        multiplier: 1,
+        description: "Like New, no visible signs of previous usage.",
+        isDefault: true
+      },
+      {
+        id: "good",
+        label: "Good",
+        percent: 85,
+        multiplier: 0.85,
+        description: "Light signs of use, minor scratches, fully functional. No dents."
+      },
+      {
+        id: "fair",
+        label: "Fair",
+        percent: 75,
+        multiplier: 0.75,
+        description: "Moderate wear, scratches, scuffs. May have small dents. Fully functional."
+      },
+      {
+        id: "poor",
+        label: "Poor",
+        percent: 60,
+        multiplier: 0.6,
+        description: "Heavy wear, significant damage. Dents, deep scratches. May have issues."
+      }
+    ],
+    device: {
+      id: deviceId,
+      model: "Dell G15 5510 Intel Core i5 10th Gen",
+      type: "laptop"
+    },
+    minimumOffer: 1
+  };
+}
+async function revalidateCalculatorConfig(deviceId) {
+  try {
+    const { revalidateTag } = await import('next/cache');
+    revalidateTag(`calculator-config-${deviceId}`);
+    console.log(`[revalidateCalculatorConfig] Cache cleared for ${deviceId}`);
+  } catch (error) {
+    console.error("[revalidateCalculatorConfig] Error:", error);
+    throw error;
+  }
+}
+
+// src/index.ts
+var VERSION = "2.0.0";
+
+export { CalculatorErrorBoundary, CompactConditionSelector, CompactPriceDisplay, ConditionTabs, DefectCheckbox, DefectCheckboxList, OfferCalculator, PriceDisplay, VERSION, calculateEffectiveDiscount, calculateOffer, fetchCalculatorConfig, formatCurrency, formatValidationErrors, getMockCalculatorConfig, hasErrors, normalizeConfig, revalidateCalculatorConfig, useDefectCheckbox, useOfferCalculator, validateConfig };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map