@gabrielerandelli/minus-tracker 0.6.0 → 0.7.0

package/dist/index.js

@@ -110,6 +110,10 @@ function warningToEnglish(w) {
       return `Row ${w.row}: no ECB rate for ${w.currency} on ${w.date} \u2014 skipped`;
     case "QUANTITY_ZERO":
       return `Row ${w.row}: quantity is 0 \u2014 skipped`;
+    case "MISSING_ISIN_INCOME":
+      return `Row ${w.row}: blank ISIN on income row \u2014 skipped`;
+    case "ORPHAN_WITHHOLDING":
+      return `Withholding row for ${w.isin} on ${w.date}: no matching income row \u2014 skipped`;
   }
 }
 
@@ -125,6 +129,8 @@ var REQUIRED_COLUMNS = [
   "Transaction costs currency",
   "Product"
 ];
+var INCOME_KEYWORDS = ["DIVIDEND", "COUPON", "INTEREST", "CEDOLA"];
+var TAX_KEYWORDS = ["DIVIDEND TAX", "WITHHOLDING", "RITENUTA"];
 function parseCSVRow(line) {
   const fields = [];
   let i = 0;
@@ -166,6 +172,7 @@ function parseDate(ddmmyyyy) {
 var DEGIROParser = class {
   _warningEntries = [];
   _snapshot;
+  _incomeRows = [];
   constructor(snapshot) {
     this._snapshot = snapshot;
   }
@@ -182,6 +189,7 @@ var DEGIROParser = class {
    */
   parse(csv) {
     this._warningEntries = [];
+    this._incomeRows = [];
     if (typeof csv !== "string" || csv.includes("\0")) {
       throw new ParseError("INVALID_CSV");
     }
@@ -206,17 +214,70 @@ var DEGIROParser = class {
     }
     const snapshot = this._snapshot ?? getActiveSnapshot();
     const transactions = [];
+    const incomeCandidates = [];
+    const withholdingCandidates = [];
     for (let r = 1; r < rows.length; r++) {
       const row = rows[r];
       const rowIndex = r + 1;
       if (row.every((cell) => cell.trim() === "")) continue;
       const get = (col) => (row[colIndex[col]] ?? "").trim();
       const isin = get("ISIN");
+      const product = get("Product");
+      const qtyStr = get("Quantity");
+      const rawQty = parseFloat(qtyStr);
+      const qtyIsZeroOrBlank = qtyStr === "" || isNaN(rawQty) || rawQty === 0;
+      if (qtyIsZeroOrBlank) {
+        const upperProduct = product.toUpperCase();
+        const isTaxKeyword = TAX_KEYWORDS.some((k) => upperProduct.includes(k));
+        const isIncomeKeyword = !isTaxKeyword && INCOME_KEYWORDS.some((k) => upperProduct.includes(k));
+        if (isTaxKeyword || isIncomeKeyword) {
+          const rawLocalValue = parseFloat(get("Local value"));
+          const localValue = isNaN(rawLocalValue) ? 0 : rawLocalValue;
+          const isoDate2 = parseDate(get("Date"));
+          if (isTaxKeyword && localValue < 0) {
+            if (!isin) {
+              this._warningEntries.push({
+                code: "MISSING_ISIN_INCOME",
+                row: rowIndex
+              });
+              continue;
+            }
+            withholdingCandidates.push({
+              isin,
+              date: isoDate2,
+              amount: Math.abs(localValue),
+              row: rowIndex
+            });
+            continue;
+          }
+          if (isIncomeKeyword && localValue > 0) {
+            if (!isin) {
+              this._warningEntries.push({
+                code: "MISSING_ISIN_INCOME",
+                row: rowIndex
+              });
+              continue;
+            }
+            const incomeType = upperProduct.includes(
+              "DIVIDEND"
+            ) ? "dividend" : "coupon";
+            incomeCandidates.push({
+              isin,
+              product,
+              date: isoDate2,
+              incomeType,
+              localValue,
+              currency: get("Local value currency"),
+              row: rowIndex
+            });
+            continue;
+          }
+        }
+      }
       if (!isin) {
         this._warningEntries.push({ code: "MISSING_ISIN", row: rowIndex });
         continue;
       }
-      const rawQty = parseFloat(get("Quantity"));
       if (isNaN(rawQty) || rawQty === 0) {
         this._warningEntries.push({ code: "QUANTITY_ZERO", row: rowIndex });
         continue;
@@ -257,7 +318,6 @@ var DEGIROParser = class {
       const rawFees = parseFloat(get("Transaction costs"));
       const feesEUR = Math.abs(isNaN(rawFees) ? 0 : rawFees);
       const pricePerUnit = parseFloat(get("Price"));
-      const product = get("Product");
       transactions.push({
         isin,
         product,
@@ -272,6 +332,73 @@ var DEGIROParser = class {
         fxRate
       });
     }
+    const withholdingByKey = /* @__PURE__ */ new Map();
+    for (const w of withholdingCandidates) {
+      const key = `${w.isin}|${w.date}`;
+      const existing = withholdingByKey.get(key);
+      withholdingByKey.set(key, {
+        isin: w.isin,
+        date: w.date,
+        amount: (existing?.amount ?? 0) + w.amount
+      });
+    }
+    const consumedKeys = /* @__PURE__ */ new Set();
+    const incomeRows = [];
+    for (const c of incomeCandidates) {
+      const key = `${c.isin}|${c.date}`;
+      const matchedWithholding = withholdingByKey.get(key);
+      let grossAmount;
+      let withholdingTax;
+      let fxRate;
+      if (c.currency === "EUR") {
+        grossAmount = Math.abs(c.localValue);
+        withholdingTax = matchedWithholding?.amount ?? 0;
+        fxRate = void 0;
+      } else {
+        const rate = lookupRate(c.currency, c.date, snapshot);
+        if (rate === null) {
+          if (snapshot[c.currency] === void 0) {
+            this._warningEntries.push({
+              code: "UNSUPPORTED_CURRENCY",
+              row: c.row,
+              currency: c.currency
+            });
+          } else {
+            this._warningEntries.push({
+              code: "NO_ECB_RATE",
+              row: c.row,
+              currency: c.currency,
+              date: c.date
+            });
+          }
+          continue;
+        }
+        grossAmount = Math.abs(c.localValue) / rate;
+        withholdingTax = matchedWithholding ? matchedWithholding.amount / rate : 0;
+        fxRate = rate;
+      }
+      if (matchedWithholding) consumedKeys.add(key);
+      incomeRows.push({
+        isin: c.isin,
+        product: c.product,
+        date: c.date,
+        incomeType: c.incomeType,
+        grossAmount,
+        withholdingTax,
+        currency: c.currency,
+        fxRate
+      });
+    }
+    for (const [key, w] of withholdingByKey) {
+      if (!consumedKeys.has(key)) {
+        this._warningEntries.push({
+          code: "ORPHAN_WITHHOLDING",
+          isin: w.isin,
+          date: w.date
+        });
+      }
+    }
+    this._incomeRows = incomeRows;
     return transactions;
   }
   get warnings() {
@@ -280,12 +407,136 @@ var DEGIROParser = class {
   get warningEntries() {
     return this._warningEntries;
   }
+  get incomeRows() {
+    return this._incomeRows;
+  }
 };
 
-// src/calculator/index.ts
+// src/dichiarazione/engine.ts
+import { writeFile } from "fs/promises";
 function roundHalfUp(x) {
   return Math.sign(x) * Math.round(Math.abs(x) * 100) / 100;
 }
+function buildQuadroRT(bucketB, carryForward, taxYear) {
+  const plusvalenze = bucketB.plusvalenze;
+  const minusvalenze = bucketB.minusvalenze;
+  const differenza = roundHalfUp(plusvalenze - minusvalenze);
+  if (differenza > 0) {
+    const sorted = [...carryForward].sort((a, b) => a.year - b.year);
+    let remaining = differenza;
+    const carryForwardApplied = [];
+    for (const entry of sorted) {
+      if (taxYear - entry.year > 4) continue;
+      const consumed = Math.min(entry.amount, remaining);
+      if (consumed > 0) {
+        carryForwardApplied.push({
+          annoOrigine: entry.year,
+          importo: roundHalfUp(consumed)
+        });
+        remaining -= consumed;
+      }
+    }
+    const imponibileNetto = roundHalfUp(remaining);
+    const imposta = roundHalfUp(imponibileNetto * 0.26);
+    return {
+      plusvalenze,
+      minusvalenze,
+      differenza,
+      carryForwardApplied,
+      imponibileNetto,
+      imposta,
+      carryForwardRiportato: []
+    };
+  } else if (differenza < 0) {
+    return {
+      plusvalenze,
+      minusvalenze,
+      differenza,
+      carryForwardApplied: [],
+      imponibileNetto: 0,
+      imposta: 0,
+      carryForwardRiportato: [
+        { annoOrigine: taxYear, importo: roundHalfUp(Math.abs(differenza)) }
+      ]
+    };
+  } else {
+    return {
+      plusvalenze,
+      minusvalenze,
+      differenza: 0,
+      carryForwardApplied: [],
+      imponibileNetto: 0,
+      imposta: 0,
+      carryForwardRiportato: []
+    };
+  }
+}
+function buildQuadroRM(bucketA, incomeRows, taxYear) {
+  const groups = bucketA?.groups ?? [];
+  const group26 = groups.find((g) => g.taxRate === 0.26);
+  const group125 = groups.find((g) => g.taxRate === 0.125);
+  const capitaleAliquota26 = {
+    plusvalenze: group26?.plusvalenze ?? 0,
+    imposta: group26?.imposta ?? 0
+  };
+  const capitaleAliquota125 = {
+    plusvalenze: group125?.plusvalenze ?? 0,
+    imposta: group125?.imposta ?? 0
+  };
+  const dividendiEsteri = incomeRows.filter((r) => r.incomeType === "dividend").map((r) => ({
+    isin: r.isin,
+    prodotto: r.product,
+    lordo: r.grossAmount,
+    rittenutaEstera: r.withholdingTax
+  }));
+  const cedole = incomeRows.filter((r) => r.incomeType === "coupon").map((r) => ({
+    isin: r.isin,
+    prodotto: r.product,
+    importo: r.grossAmount,
+    rittenutaEstera: r.withholdingTax
+  }));
+  return {
+    capitaleAliquota26,
+    capitaleAliquota125,
+    dividendiEsteri,
+    cedole
+  };
+}
+function buildDichiarazioneReport(quadroRT, quadroRM, taxYear) {
+  const version = 1;
+  const modello = "Redditi PF";
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version,
+    annoImposta: taxYear,
+    modello,
+    generatedAt,
+    quadroRT,
+    quadroRM,
+    exportTo: async (path2) => {
+      await writeFile(
+        path2,
+        JSON.stringify(
+          {
+            version,
+            annoImposta: taxYear,
+            modello,
+            generatedAt,
+            quadroRT,
+            quadroRM
+          },
+          null,
+          2
+        )
+      );
+    }
+  };
+}
+
+// src/calculator/index.ts
+function roundHalfUp2(x) {
+  return Math.sign(x) * Math.round(Math.abs(x) * 100) / 100;
+}
 function inferTaxYear(transactions) {
   const counts = {};
   for (const t of transactions) {
@@ -377,9 +628,9 @@ var Calculator = class {
             sellDate: tx.date,
             buyPriceEUR: lot.pricePerUnitEUR,
             sellPriceEUR: sellPricePerUnitEUR,
-            buyCostEUR: roundHalfUp(buyCostEUR),
-            sellProceedsEUR: roundHalfUp(sellProceedsEUR),
-            gainLossEUR: roundHalfUp(gainLossEUR),
+            buyCostEUR: roundHalfUp2(buyCostEUR),
+            sellProceedsEUR: roundHalfUp2(sellProceedsEUR),
+            gainLossEUR: roundHalfUp2(gainLossEUR),
             buyFxRate: lot.fxRate,
             sellFxRate: tx.fxRate
           });
@@ -434,12 +685,12 @@ var Calculator = class {
       const bucketAGroups = [...groupsByRate.entries()].map(([taxRate, g]) => ({
         taxRate,
         assetClasses: [...g.assetClasses],
-        plusvalenze: roundHalfUp(g.plusvalenze),
-        imposta: roundHalfUp(g.plusvalenze * taxRate)
+        plusvalenze: roundHalfUp2(g.plusvalenze),
+        imposta: roundHalfUp2(g.plusvalenze * taxRate)
       }));
       const bucketAReport = {
         groups: bucketAGroups,
-        totalImposta: roundHalfUp(
+        totalImposta: roundHalfUp2(
           bucketAGroups.reduce((s, g) => s + g.imposta, 0)
         )
       };
@@ -450,8 +701,8 @@ var Calculator = class {
         if (lot.gainLossEUR >= 0) bPlusvalenze += lot.gainLossEUR;
         else bMinusvalenze += Math.abs(lot.gainLossEUR);
       }
-      bPlusvalenze = roundHalfUp(bPlusvalenze);
-      bMinusvalenze = roundHalfUp(bMinusvalenze);
+      bPlusvalenze = roundHalfUp2(bPlusvalenze);
+      bMinusvalenze = roundHalfUp2(bMinusvalenze);
       const carryForwards = [...this._options.carryForward ?? []].sort(
         (a, b) => a.year - b.year
       );
@@ -464,11 +715,11 @@ var Calculator = class {
         carryForwardApplied += consumed;
         remaining -= consumed;
       }
-      carryForwardApplied = roundHalfUp(carryForwardApplied);
-      const bNetResult = roundHalfUp(
+      carryForwardApplied = roundHalfUp2(carryForwardApplied);
+      const bNetResult = roundHalfUp2(
         bPlusvalenze - bMinusvalenze - carryForwardApplied
       );
-      const carryForwardRemaining = roundHalfUp(Math.max(0, -bNetResult));
+      const carryForwardRemaining = roundHalfUp2(Math.max(0, -bNetResult));
       const bucketBReport = {
         plusvalenze: bPlusvalenze,
         minusvalenze: bMinusvalenze,
@@ -476,18 +727,41 @@ var Calculator = class {
         carryForwardRemaining,
         netResult: bNetResult
       };
+      const allIncomeRows = this._options.incomeRows ?? [];
+      const filteredIncomeRows = allIncomeRows.filter(
+        (row) => new Date(row.date).getFullYear() === taxYear
+      );
+      if (filteredIncomeRows.length < allIncomeRows.length) {
+        warnings.push(`Income rows outside tax year ${taxYear} were skipped.`);
+      }
+      const quadroRT = buildQuadroRT(
+        bucketBReport,
+        this._options.carryForward ?? [],
+        taxYear
+      );
+      const quadroRM = buildQuadroRM(
+        bucketAGroups.length > 0 ? bucketAReport : void 0,
+        filteredIncomeRows,
+        taxYear
+      );
+      const dichiarazioneReport = buildDichiarazioneReport(
+        quadroRT,
+        quadroRM,
+        taxYear
+      );
       return {
         method,
         taxYear,
-        plusvalenze: roundHalfUp(plusvalenze),
-        minusvalenze: roundHalfUp(minusvalenze),
-        netResult: roundHalfUp(plusvalenze - minusvalenze),
+        plusvalenze: roundHalfUp2(plusvalenze),
+        minusvalenze: roundHalfUp2(minusvalenze),
+        netResult: roundHalfUp2(plusvalenze - minusvalenze),
         lots: matchedLots,
         ratesUsed,
         warnings,
         generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         bucketA: bucketAGroups.length > 0 ? bucketAReport : void 0,
-        bucketB: bucketBReport
+        bucketB: bucketBReport,
+        dichiarazione: dichiarazioneReport
       };
     } else {
       const allIsins = [...new Set(this._transactions.map((t) => t.isin))];
@@ -502,9 +776,9 @@ var Calculator = class {
     return {
       method,
       taxYear,
-      plusvalenze: roundHalfUp(plusvalenze),
-      minusvalenze: roundHalfUp(minusvalenze),
-      netResult: roundHalfUp(plusvalenze - minusvalenze),
+      plusvalenze: roundHalfUp2(plusvalenze),
+      minusvalenze: roundHalfUp2(minusvalenze),
+      netResult: roundHalfUp2(plusvalenze - minusvalenze),
       lots: matchedLots,
       ratesUsed,
       warnings,