@classytic/payroll 2.7.5 → 2.8.0

package/dist/calculators/index.js

@@ -45,6 +45,11 @@ function applyTaxBrackets(amount, brackets) {
 }
 
 // src/utils/date.ts
+function toUTCDateString(date) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
 function isEffectiveForPeriod(item, periodStart, periodEnd) {
   const effectiveFrom = item.effectiveFrom ? new Date(item.effectiveFrom) : /* @__PURE__ */ new Date(0);
   const effectiveTo = item.effectiveTo ? new Date(item.effectiveTo) : /* @__PURE__ */ new Date("2099-12-31");
@@ -57,7 +62,7 @@ var DEFAULT_WORK_SCHEDULE = {
 function countWorkingDays(startDate, endDate, options = {}) {
   const workDays = options.workingDays || DEFAULT_WORK_SCHEDULE.workingDays;
   const holidaySet = new Set(
-    (options.holidays || []).map((d) => new Date(d).toDateString())
+    (options.holidays || []).map((d) => toUTCDateString(d))
   );
   let totalDays = 0;
   let workingDays = 0;
@@ -69,7 +74,7 @@ function countWorkingDays(startDate, endDate, options = {}) {
   end.setHours(0, 0, 0, 0);
   while (current <= end) {
     totalDays++;
-    const isHoliday = holidaySet.has(current.toDateString());
+    const isHoliday = holidaySet.has(toUTCDateString(current));
     const isWorkDay = workDays.includes(current.getDay());
     if (isHoliday) {
       holidays++;
@@ -83,6 +88,52 @@ function countWorkingDays(startDate, endDate, options = {}) {
   return { totalDays, workingDays, weekends, holidays };
 }
 
+// src/config.ts
+var ORG_ROLES = {
+  OWNER: {
+    key: "owner",
+    label: "Owner",
+    description: "Full organization access (set by Organization model)"
+  },
+  MANAGER: {
+    key: "manager",
+    label: "Manager",
+    description: "Management and administrative features"
+  },
+  TRAINER: {
+    key: "trainer",
+    label: "Trainer",
+    description: "Training and coaching features"
+  },
+  STAFF: {
+    key: "staff",
+    label: "Staff",
+    description: "General staff access to basic features"
+  },
+  INTERN: {
+    key: "intern",
+    label: "Intern",
+    description: "Limited access for interns"
+  },
+  CONSULTANT: {
+    key: "consultant",
+    label: "Consultant",
+    description: "Project-based consultant access"
+  }
+};
+Object.values(ORG_ROLES).map((role) => role.key);
+function getPayPeriodsPerYear(frequency) {
+  const periodsMap = {
+    monthly: 12,
+    bi_weekly: 26,
+    weekly: 52,
+    daily: 365,
+    hourly: 2080
+    // Assuming 40 hours/week * 52 weeks
+  };
+  return periodsMap[frequency];
+}
+
 // src/calculators/prorating.calculator.ts
 function calculateProRating(input) {
   const { hireDate, terminationDate, periodStart, periodEnd, workingDays, holidays = [] } = input;
@@ -116,7 +167,7 @@ function calculateProRating(input) {
   };
 }
 function applyProRating(baseAmount, ratio) {
-  return Math.round(baseAmount * ratio);
+  return roundMoney(baseAmount * ratio, 2);
 }
 function shouldProRate(hireDate, terminationDate, periodStart, periodEnd) {
   const hire = new Date(hireDate);
@@ -133,7 +184,7 @@ function calculateAttendanceDeduction(input) {
   const actual = Math.max(0, actualWorkingDays);
   const rate = Math.max(0, dailyRate);
   const absentDays = Math.max(0, expected - actual);
-  const deductionAmount = Math.round(absentDays * rate);
+  const deductionAmount = roundMoney(absentDays * rate, 2);
   return {
     absentDays,
     deductionAmount,
@@ -143,20 +194,20 @@ function calculateAttendanceDeduction(input) {
 }
 function calculateDailyRate(monthlySalary, workingDays) {
   if (workingDays <= 0) return 0;
-  return Math.round(monthlySalary / workingDays);
+  return roundMoney(monthlySalary / workingDays, 2);
 }
 function calculateHourlyRate(monthlySalary, workingDays, hoursPerDay = 8) {
   const dailyRate = calculateDailyRate(monthlySalary, workingDays);
   if (hoursPerDay <= 0) return 0;
-  return Math.round(dailyRate / hoursPerDay);
+  return roundMoney(dailyRate / hoursPerDay, 2);
 }
 function calculatePartialDayDeduction(dailyRate, fractionAbsent) {
   const fraction = Math.min(1, Math.max(0, fractionAbsent));
-  return Math.round(dailyRate * fraction);
+  return roundMoney(dailyRate * fraction, 2);
 }
 function calculateTotalAttendanceDeduction(input) {
   const { dailyRate, fullDayAbsences = 0, partialDayAbsences = [] } = input;
-  const fullDayDeduction = Math.round(dailyRate * Math.max(0, fullDayAbsences));
+  const fullDayDeduction = roundMoney(dailyRate * Math.max(0, fullDayAbsences), 2);
   const partialDayDeduction = partialDayAbsences.reduce(
     (sum, fraction) => sum + calculatePartialDayDeduction(dailyRate, fraction),
     0
@@ -170,7 +221,7 @@ function calculateTotalAttendanceDeduction(input) {
 
 // src/calculators/salary.calculator.ts
 function calculateSalaryBreakdown(input) {
-  const { employee, period, attendance, options = {}, config, taxBrackets } = input;
+  const { employee, period, attendance, options = {}, config, taxBrackets, taxOptions, jurisdictionTaxConfig } = input;
   const comp = employee.compensation;
   const originalBaseAmount = comp.baseAmount;
   const proRating = calculateProRatingForSalary(
@@ -187,8 +238,8 @@ function calculateSalaryBreakdown(input) {
   }
   const effectiveAllowances = (comp.allowances || []).filter((a) => isEffectiveForPeriod(a, period.startDate, period.endDate));
   const effectiveDeductions = (comp.deductions || []).filter((d) => isEffectiveForPeriod(d, period.startDate, period.endDate)).filter((d) => d.auto || d.recurring);
-  const allowances = processAllowances(effectiveAllowances, originalBaseAmount, proRating, config);
-  const deductions = processDeductions(effectiveDeductions, originalBaseAmount, proRating, config);
+  const allowances = processAllowances(effectiveAllowances, originalBaseAmount, proRating, config, options.skipProration);
+  const deductions = processDeductions(effectiveDeductions, originalBaseAmount, proRating, config, options.skipProration);
   if (!options.skipAttendance && config.attendanceIntegration && attendance) {
     const attendanceDeductionResult = calculateAttendanceDeductionFromData(
       attendance,
@@ -205,12 +256,24 @@ function calculateSalaryBreakdown(input) {
   }
   const grossSalary = calculateGross(baseAmount, allowances);
   const taxableAllowances = allowances.filter((a) => a.taxable);
-  const taxableAmount = baseAmount + sumAllowances(taxableAllowances);
+  let taxableAmount = baseAmount + sumAllowances(taxableAllowances);
+  const preTaxDeductionAmount = calculatePreTaxDeductions(
+    effectiveDeductions,
+    deductions,
+    taxOptions,
+    jurisdictionTaxConfig
+  );
+  taxableAmount = Math.max(0, taxableAmount - preTaxDeductionAmount);
+  const frequency = employee.compensation?.frequency || "monthly";
   let taxAmount = 0;
   if (!options.skipTax && taxBrackets.length > 0 && config.autoDeductions) {
-    const annualTaxable = taxableAmount * 12;
-    const annualTax = applyTaxBrackets(annualTaxable, taxBrackets);
-    taxAmount = roundMoney(annualTax / 12);
+    taxAmount = calculateEnhancedTax(
+      taxableAmount,
+      taxBrackets,
+      taxOptions,
+      jurisdictionTaxConfig,
+      frequency
+    );
   }
   if (taxAmount > 0) {
     deductions.push({
@@ -246,11 +309,11 @@ function calculateProRatingForSalary(hireDate, terminationDate, periodStart, per
     holidays
   });
 }
-function processAllowances(allowances, originalBaseAmount, proRating, config) {
+function processAllowances(allowances, originalBaseAmount, proRating, config, skipProration) {
   return allowances.map((a) => {
     let amount = a.isPercentage && a.value !== void 0 ? percentageOf(originalBaseAmount, a.value) : a.amount;
     const originalAmount = amount;
-    if (proRating.isProRated && config.allowProRating) {
+    if (proRating.isProRated && config.allowProRating && !skipProration) {
       amount = prorateAmount(amount, proRating.ratio);
     }
     return {
@@ -263,11 +326,11 @@ function processAllowances(allowances, originalBaseAmount, proRating, config) {
     };
   });
 }
-function processDeductions(deductions, originalBaseAmount, proRating, config) {
+function processDeductions(deductions, originalBaseAmount, proRating, config, skipProration) {
   return deductions.map((d) => {
     let amount = d.isPercentage && d.value !== void 0 ? percentageOf(originalBaseAmount, d.value) : d.amount;
     const originalAmount = amount;
-    if (proRating.isProRated && config.allowProRating) {
+    if (proRating.isProRated && config.allowProRating && !skipProration) {
       amount = prorateAmount(amount, proRating.ratio);
     }
     return {
@@ -298,6 +361,78 @@ function calculateAttendanceDeductionFromData(attendance, baseAmount, effectiveW
     absentDays: result.absentDays
   };
 }
+function calculatePreTaxDeductions(effectiveDeductions, processedDeductions, taxOptions, jurisdictionTaxConfig) {
+  let totalPreTax = 0;
+  for (let i = 0; i < effectiveDeductions.length; i++) {
+    const original = effectiveDeductions[i];
+    const processed = processedDeductions[i];
+    if (original.reducesTaxableIncome) {
+      totalPreTax += processed?.amount || 0;
+    }
+  }
+  if (jurisdictionTaxConfig?.preTaxDeductionTypes?.length) {
+    const preTaxTypes = new Set(jurisdictionTaxConfig.preTaxDeductionTypes);
+    for (let i = 0; i < effectiveDeductions.length; i++) {
+      const original = effectiveDeductions[i];
+      const processed = processedDeductions[i];
+      if (original.reducesTaxableIncome) continue;
+      if (preTaxTypes.has(original.type)) {
+        totalPreTax += processed?.amount || 0;
+      }
+    }
+  }
+  if (taxOptions?.preTaxDeductions?.length) {
+    for (const deduction of taxOptions.preTaxDeductions) {
+      totalPreTax += deduction.amount;
+    }
+  }
+  return roundMoney(totalPreTax);
+}
+function calculateEnhancedTax(periodTaxable, taxBrackets, taxOptions, jurisdictionTaxConfig, frequency = "monthly") {
+  const periodsPerYear = getPayPeriodsPerYear(frequency);
+  let annualTaxable = periodTaxable * periodsPerYear;
+  const threshold = getApplicableThreshold(taxOptions, jurisdictionTaxConfig);
+  if (threshold > 0) {
+    annualTaxable = Math.max(0, annualTaxable - threshold);
+  }
+  let annualTax = applyTaxBrackets(annualTaxable, taxBrackets);
+  if (taxOptions?.taxCredits?.length && annualTax > 0) {
+    annualTax = applyTaxCredits(annualTax, taxOptions.taxCredits);
+  }
+  return roundMoney(annualTax / periodsPerYear);
+}
+function getApplicableThreshold(taxOptions, jurisdictionTaxConfig) {
+  if (taxOptions?.standardDeductionOverride !== void 0) {
+    return taxOptions.standardDeductionOverride;
+  }
+  if (taxOptions?.taxpayerCategory) {
+    const category = taxOptions.taxpayerCategory;
+    if (taxOptions.thresholdOverrides?.[category] !== void 0) {
+      return taxOptions.thresholdOverrides[category];
+    }
+    if (jurisdictionTaxConfig?.thresholdsByCategory?.[category] !== void 0) {
+      return jurisdictionTaxConfig.thresholdsByCategory[category];
+    }
+  }
+  if (taxOptions?.applyStandardDeduction && jurisdictionTaxConfig?.standardDeduction) {
+    return jurisdictionTaxConfig.standardDeduction;
+  }
+  return 0;
+}
+function applyTaxCredits(annualTax, taxCredits) {
+  let remainingTax = annualTax;
+  for (const credit of taxCredits) {
+    if (remainingTax <= 0) break;
+    let creditAmount = credit.amount;
+    if (credit.maxPercent !== void 0 && credit.maxPercent > 0) {
+      const maxCredit = annualTax * credit.maxPercent;
+      creditAmount = Math.min(creditAmount, maxCredit);
+    }
+    creditAmount = Math.min(creditAmount, remainingTax);
+    remainingTax -= creditAmount;
+  }
+  return Math.max(0, remainingTax);
+}
 
 export { applyProRating, calculateAttendanceDeduction, calculateDailyRate, calculateHourlyRate, calculatePartialDayDeduction, calculateProRating, calculateSalaryBreakdown, calculateTotalAttendanceDeduction, shouldProRate };
 //# sourceMappingURL=index.js.map