@gabrielerandelli/minus-tracker 0.7.0 → 0.8.0

package/dist/index.js

@@ -1000,7 +1000,7 @@ function classifyByType(isin, securityType, product, warnings) {
     };
   }
   warnings.push(
-    `Unrecognized type: ${securityType}. Please classify manually.`
+    `Unrecognized type for ${isin}: ${securityType}. Please classify manually.`
   );
   return {
     product,
@@ -1013,6 +1013,84 @@ function classifyByType(isin, securityType, product, warnings) {
     source: "user"
   };
 }
+var ASSET_CLASS_DEFAULTS = {
+  ETF: {
+    assetClass: "ETF",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  },
+  Stock: {
+    assetClass: "Stock",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  ETC: {
+    assetClass: "ETC",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  GovtBondWL: {
+    assetClass: "GovtBondWL",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.125,
+    whiteListed: true
+  },
+  GovtBondOther: {
+    assetClass: "GovtBondOther",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: false
+  },
+  CorpBond: {
+    assetClass: "CorpBond",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  Derivative: {
+    assetClass: "Derivative",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  LeverageCert: {
+    assetClass: "LeverageCert",
+    bucketGain: "B",
+    bucketLoss: "B",
+    taxRate: 0,
+    whiteListed: null
+  },
+  CapProtectedCert: {
+    assetClass: "CapProtectedCert",
+    bucketGain: "A",
+    bucketLoss: "B",
+    taxRate: 0.26,
+    whiteListed: null
+  }
+};
+function buildEntryFromAssetClass(assetClass, product) {
+  const mapped = ASSET_CLASS_DEFAULTS[assetClass];
+  return {
+    product,
+    assetClass: mapped.assetClass,
+    bucketGain: mapped.bucketGain,
+    bucketLoss: mapped.bucketLoss,
+    taxRate: mapped.taxRate,
+    whiteListed: mapped.whiteListed,
+    confirmedByUser: true,
+    source: "user"
+  };
+}
 var Classifier = class {
   interactive;
   constructor(options) {
@@ -1034,7 +1112,7 @@ var Classifier = class {
     }
     return parsed.classifications;
   }
-  async classify(transactions, sidecarPath, _httpPost = httpsPost) {
+  async classify(transactions, sidecarPath, options, _httpPost = httpsPost) {
     const isinToProduct = /* @__PURE__ */ new Map();
     for (const tx of transactions) {
       if (tx.isin && !isinToProduct.has(tx.isin)) {
@@ -1042,13 +1120,21 @@ var Classifier = class {
       }
     }
     const confirmed = {};
-    if (fs2.existsSync(sidecarPath)) {
-      const existingMap = await this.load(sidecarPath);
-      for (const [isin, entry] of Object.entries(existingMap)) {
-        if (entry.confirmedByUser) {
-          confirmed[isin] = entry;
+    if (sidecarPath !== void 0) {
+      if (fs2.existsSync(sidecarPath)) {
+        const existingMap = await this.load(sidecarPath);
+        for (const [isin, entry] of Object.entries(existingMap)) {
+          if (entry.confirmedByUser) {
+            confirmed[isin] = entry;
+          }
         }
       }
+    } else if (options?.existingClassification) {
+      Object.assign(confirmed, options.existingClassification);
+    }
+    for (const [isin, assetClass] of Object.entries(options?.overrides ?? {})) {
+      const product = isinToProduct.get(isin) ?? isin;
+      confirmed[isin] = buildEntryFromAssetClass(assetClass, product);
     }
     const toProcess = [];
     for (const isin of isinToProduct.keys()) {
@@ -1058,76 +1144,100 @@ var Classifier = class {
     }
     const warnings = [];
     const newEntries = {};
-    const BATCH_SIZE = 10;
-    for (let i = 0; i < toProcess.length; i += BATCH_SIZE) {
-      if (i > 0) {
-        await new Promise((resolve) => setTimeout(resolve, 6e3));
+    if (options?.offline) {
+      for (const isin of toProcess) {
+        const product = isinToProduct.get(isin) ?? isin;
+        warnings.push(
+          `Unrecognized type for ${isin}: unknown. Please classify manually.`
+        );
+        newEntries[isin] = {
+          product,
+          assetClass: "Stock",
+          bucketGain: "B",
+          bucketLoss: "B",
+          taxRate: 0,
+          whiteListed: null,
+          confirmedByUser: false,
+          source: "user"
+        };
       }
-      const batch = toProcess.slice(i, i + BATCH_SIZE);
-      const requestBody = JSON.stringify(
-        batch.map((isin) => ({ idType: "ID_ISIN", idValue: isin }))
-      );
-      let response = null;
-      for (let attempt = 0; attempt < 2; attempt++) {
-        try {
-          const r = await _httpPost(
-            "https://api.openfigi.com/v3/mapping",
-            requestBody,
-            1e4
-          );
-          if (r.status < 500) {
-            response = r;
-            break;
+    } else {
+      const BATCH_SIZE = 10;
+      const totalBatches = Math.ceil(toProcess.length / BATCH_SIZE);
+      for (let i = 0; i < toProcess.length; i += BATCH_SIZE) {
+        if (i > 0) {
+          await new Promise((resolve) => setTimeout(resolve, 6e3));
+        }
+        const batch = toProcess.slice(i, i + BATCH_SIZE);
+        const requestBody = JSON.stringify(
+          batch.map((isin) => ({ idType: "ID_ISIN", idValue: isin }))
+        );
+        let response = null;
+        for (let attempt = 0; attempt < 2; attempt++) {
+          try {
+            const r = await _httpPost(
+              "https://api.openfigi.com/v3/mapping",
+              requestBody,
+              1e4
+            );
+            if (r.status < 500) {
+              response = r;
+              break;
+            }
+          } catch {
+            throw new ClassificationError("NETWORK_ERROR");
           }
-        } catch {
+        }
+        if (response === null) {
           throw new ClassificationError("NETWORK_ERROR");
         }
-      }
-      if (response === null) {
-        throw new ClassificationError("NETWORK_ERROR");
-      }
-      const results = JSON.parse(response.data);
-      for (let j = 0; j < batch.length; j++) {
-        const isin = batch[j];
-        const result = results[j];
-        const product = isinToProduct.get(isin) ?? isin;
-        if (!result || result.error || !result.data || result.data.length === 0) {
-          warnings.push(
-            `Unrecognized type: unknown. Please classify manually.`
-          );
-          newEntries[isin] = {
-            product,
-            assetClass: "Stock",
-            bucketGain: "B",
-            bucketLoss: "B",
-            taxRate: 0,
-            whiteListed: null,
-            confirmedByUser: false,
-            source: "user"
-          };
-          continue;
+        const results = JSON.parse(response.data);
+        for (let j = 0; j < batch.length; j++) {
+          const isin = batch[j];
+          const result = results[j];
+          const product = isinToProduct.get(isin) ?? isin;
+          if (!result || result.error || !result.data || result.data.length === 0) {
+            warnings.push(
+              `Unrecognized type for ${isin}: unknown. Please classify manually.`
+            );
+            newEntries[isin] = {
+              product,
+              assetClass: "Stock",
+              bucketGain: "B",
+              bucketLoss: "B",
+              taxRate: 0,
+              whiteListed: null,
+              confirmedByUser: false,
+              source: "user"
+            };
+            continue;
+          }
+          const st = result.data[0]?.securityType;
+          const st2 = result.data[0]?.securityType2;
+          const typeToUse = st && isKnownType(st) ? st : st2 && isKnownType(st2) ? st2 : st ?? st2 ?? "Unknown";
+          newEntries[isin] = classifyByType(isin, typeToUse, product, warnings);
         }
-        const st = result.data[0]?.securityType;
-        const st2 = result.data[0]?.securityType2;
-        const typeToUse = st && isKnownType(st) ? st : st2 && isKnownType(st2) ? st2 : st ?? st2 ?? "Unknown";
-        newEntries[isin] = classifyByType(isin, typeToUse, product, warnings);
+        const batchIndex = i / BATCH_SIZE;
+        options?.onBatchProgress?.(batchIndex + 1, totalBatches);
       }
     }
     const mergedMap = { ...newEntries, ...confirmed };
-    const sidecarContent = JSON.stringify(
-      {
-        version: 1,
-        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        classifications: mergedMap,
-        warnings
-      },
-      null,
-      2
-    );
-    try {
-      fs2.writeFileSync(sidecarPath, sidecarContent, "utf-8");
-    } catch {
-      throw new ClassificationError("WRITE_ERROR");
+    if (sidecarPath !== void 0) {
+      const sidecarContent = JSON.stringify(
+        {
+          version: 1,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          classifications: mergedMap,
+          warnings
+        },
+        null,
+        2
+      );
+      try {
+        fs2.writeFileSync(sidecarPath, sidecarContent, "utf-8");
+      } catch {
+        throw new ClassificationError("WRITE_ERROR");
+      }
     }
     return mergedMap;
   }