fin-ratios 0.1.1 → 0.3.0

package/dist/hooks/index.cjs

@@ -0,0 +1,614 @@
+'use strict';
+
+var react = require('react');
+
+// src/hooks/index.ts
+
+// src/utils/safe-divide.ts
+function safeDivide(numerator, denominator) {
+  if (numerator == null || denominator == null) return null;
+  if (denominator === 0) return null;
+  return numerator / denominator;
+}
+
+// src/ratios/valuation/index.ts
+function pe(input) {
+  return safeDivide(input.marketCap, input.netIncome);
+}
+pe.formula = "Market Capitalization / Net Income";
+pe.description = "Trailing price-to-earnings ratio. How much investors pay per dollar of earnings.";
+function peg(input) {
+  return safeDivide(input.peRatio, input.epsGrowthRatePercent);
+}
+peg.formula = "P/E Ratio / EPS Annual Growth Rate (%)";
+peg.description = "PEG ratio. < 1 may indicate undervaluation relative to growth.";
+function pb(input) {
+  return safeDivide(input.marketCap, input.totalEquity);
+}
+pb.formula = "Market Capitalization / Total Shareholders Equity";
+pb.description = "Price-to-book ratio. < 1 may indicate trading below net asset value.";
+function ps(input) {
+  return safeDivide(input.marketCap, input.revenue);
+}
+ps.formula = "Market Capitalization / Revenue";
+ps.description = "Price-to-sales ratio. Useful when earnings are negative.";
+function pFcf(input) {
+  const fcf = input.operatingCashFlow - Math.abs(input.capex);
+  return safeDivide(input.marketCap, fcf);
+}
+pFcf.formula = "Market Capitalization / (Operating Cash Flow - Capex)";
+pFcf.description = "Price-to-free-cash-flow. Often considered cleaner than P/E.";
+function evEbitda(input) {
+  return safeDivide(input.enterpriseValue, input.ebitda);
+}
+evEbitda.formula = "Enterprise Value / EBITDA";
+evEbitda.description = "Capital-structure-neutral valuation multiple. Popular in LBO analysis.";
+function evEbit(input) {
+  return safeDivide(input.enterpriseValue, input.ebit);
+}
+evEbit.formula = "Enterprise Value / EBIT";
+evEbit.description = "Like EV/EBITDA but accounts for depreciation-heavy businesses.";
+function evRevenue(input) {
+  return safeDivide(input.enterpriseValue, input.revenue);
+}
+evRevenue.formula = "Enterprise Value / Revenue";
+evRevenue.description = "Useful for high-growth companies without positive EBITDA.";
+function evFcf(input) {
+  return safeDivide(input.enterpriseValue, input.freeCashFlow);
+}
+evFcf.formula = "Enterprise Value / Free Cash Flow";
+evFcf.description = "EV-to-free-cash-flow. Preferred by value investors.";
+function tobinsQ(input) {
+  const marketValue = input.marketCap + input.totalDebt;
+  return safeDivide(marketValue, input.totalAssets);
+}
+tobinsQ.formula = "(Market Cap + Total Debt) / Total Assets";
+tobinsQ.description = "Q > 1 = market values firm above replacement cost. Q < 1 = below.";
+function grahamNumber(input) {
+  if (input.eps <= 0 || input.bookValuePerShare <= 0) return null;
+  return Math.sqrt(22.5 * input.eps * input.bookValuePerShare);
+}
+grahamNumber.formula = "sqrt(22.5 \xD7 EPS \xD7 Book Value Per Share)";
+grahamNumber.description = "Ben Graham's estimate of fair value. Buy below, sell above.";
+
+// src/ratios/profitability/index.ts
+function grossMargin(input) {
+  return safeDivide(input.grossProfit, input.revenue);
+}
+grossMargin.formula = "Gross Profit / Revenue";
+grossMargin.description = "Percentage of revenue remaining after cost of goods sold.";
+function operatingMargin(input) {
+  return safeDivide(input.ebit, input.revenue);
+}
+operatingMargin.formula = "EBIT / Revenue";
+operatingMargin.description = "Operating income as a percentage of revenue.";
+function ebitdaMargin(input) {
+  return safeDivide(input.ebitda, input.revenue);
+}
+ebitdaMargin.formula = "EBITDA / Revenue";
+ebitdaMargin.description = "Earnings before interest, taxes, D&A as % of revenue.";
+function netProfitMargin(input) {
+  return safeDivide(input.netIncome, input.revenue);
+}
+netProfitMargin.formula = "Net Income / Revenue";
+netProfitMargin.description = "Bottom-line profitability after all expenses.";
+function roe(input) {
+  return safeDivide(input.netIncome, input.avgTotalEquity);
+}
+roe.formula = "Net Income / Average Total Equity";
+roe.description = "Return on equity \u2014 how efficiently a company uses shareholder capital.";
+function roa(input) {
+  return safeDivide(input.netIncome, input.avgTotalAssets);
+}
+roa.formula = "Net Income / Average Total Assets";
+roa.description = "Return on assets \u2014 how efficiently assets are used to generate profit.";
+function nopat(input) {
+  return input.ebit * (1 - input.taxRate);
+}
+nopat.formula = "EBIT \xD7 (1 - Effective Tax Rate)";
+nopat.description = "Net operating profit after tax \u2014 removes financing effects.";
+function roic(input) {
+  return safeDivide(input.nopat, input.investedCapital);
+}
+roic.formula = "NOPAT / Invested Capital";
+roic.description = "ROIC vs WACC determines whether a company creates or destroys value.";
+function roce(input) {
+  const capitalEmployed = input.totalAssets - input.currentLiabilities;
+  return safeDivide(input.ebit, capitalEmployed);
+}
+roce.formula = "EBIT / (Total Assets - Current Liabilities)";
+roce.description = "Return on capital employed. Includes both equity and long-term debt.";
+function investedCapital(input) {
+  return input.totalEquity + input.totalDebt - input.cash;
+}
+investedCapital.formula = "Total Equity + Total Debt - Excess Cash";
+investedCapital.description = "Capital deployed to generate operating returns.";
+
+// src/ratios/liquidity/index.ts
+function currentRatio(input) {
+  return safeDivide(input.currentAssets, input.currentLiabilities);
+}
+currentRatio.formula = "Current Assets / Current Liabilities";
+currentRatio.description = "Ability to pay short-term obligations. > 1 generally healthy.";
+function quickRatio(input) {
+  const liquid = input.cash + input.shortTermInvestments + input.accountsReceivable;
+  return safeDivide(liquid, input.currentLiabilities);
+}
+quickRatio.formula = "(Cash + ST Investments + Accounts Receivable) / Current Liabilities";
+quickRatio.description = "Liquidity excluding inventory. More conservative than current ratio.";
+function dso(input) {
+  return safeDivide(input.accountsReceivable * 365, input.revenue);
+}
+dso.formula = "(Accounts Receivable / Revenue) \xD7 365";
+dso.description = "Days Sales Outstanding \u2014 average days to collect payment after a sale.";
+function dio(input) {
+  return safeDivide(input.inventory * 365, input.cogs);
+}
+dio.formula = "(Inventory / COGS) \xD7 365";
+dio.description = "Days Inventory Outstanding \u2014 average days inventory is held before sale.";
+function dpo(input) {
+  return safeDivide(input.accountsPayable * 365, input.cogs);
+}
+dpo.formula = "(Accounts Payable / COGS) \xD7 365";
+dpo.description = "Days Payable Outstanding \u2014 average days taken to pay suppliers.";
+function cashConversionCycle(input) {
+  return input.dso + input.dio - input.dpo;
+}
+cashConversionCycle.formula = "DSO + DIO - DPO";
+cashConversionCycle.description = "Days from cash outflow (inventory) to cash inflow (collections). Lower is better.";
+
+// src/ratios/solvency/index.ts
+function debtToEquity(input) {
+  return safeDivide(input.totalDebt, input.totalEquity);
+}
+debtToEquity.formula = "Total Debt / Total Equity";
+debtToEquity.description = "Financial leverage. Higher = more debt-financed.";
+function netDebtToEquity(input) {
+  const netDebt = input.totalDebt - input.cash;
+  return safeDivide(netDebt, input.totalEquity);
+}
+netDebtToEquity.formula = "(Total Debt - Cash) / Total Equity";
+netDebtToEquity.description = "Net leverage ratio. Negative = net cash position.";
+function netDebtToEbitda(input) {
+  const netDebt = input.totalDebt - input.cash;
+  return safeDivide(netDebt, input.ebitda);
+}
+netDebtToEbitda.formula = "(Total Debt - Cash) / EBITDA";
+netDebtToEbitda.description = "Years to repay net debt from EBITDA. Lenders often require < 3x.";
+function debtToAssets(input) {
+  return safeDivide(input.totalDebt, input.totalAssets);
+}
+debtToAssets.formula = "Total Debt / Total Assets";
+debtToAssets.description = "Proportion of assets financed by debt.";
+function interestCoverageRatio(input) {
+  return safeDivide(input.ebit, input.interestExpense);
+}
+interestCoverageRatio.formula = "EBIT / Interest Expense";
+interestCoverageRatio.description = "Times interest is covered by operating earnings. < 1.5 is risky.";
+function equityMultiplier(input) {
+  return safeDivide(input.totalAssets, input.totalEquity);
+}
+equityMultiplier.formula = "Total Assets / Total Equity";
+equityMultiplier.description = "Leverage component of DuPont analysis.";
+
+// src/ratios/efficiency/index.ts
+function assetTurnover(input) {
+  return safeDivide(input.revenue, input.avgTotalAssets);
+}
+assetTurnover.formula = "Revenue / Average Total Assets";
+assetTurnover.description = "Sales generated per dollar of total assets.";
+function inventoryTurnover(input) {
+  return safeDivide(input.cogs, input.avgInventory);
+}
+inventoryTurnover.formula = "COGS / Average Inventory";
+inventoryTurnover.description = "How many times inventory is sold per year. Higher = less cash tied up.";
+function receivablesTurnover(input) {
+  return safeDivide(input.revenue, input.avgAccountsReceivable);
+}
+receivablesTurnover.formula = "Revenue / Average Accounts Receivable";
+receivablesTurnover.description = "How quickly the company collects what it is owed.";
+function payablesTurnover(input) {
+  return safeDivide(input.cogs, input.avgAccountsPayable);
+}
+payablesTurnover.formula = "COGS / Average Accounts Payable";
+payablesTurnover.description = "How quickly the company pays its suppliers.";
+
+// src/ratios/cashflow/index.ts
+function freeCashFlow(input) {
+  return input.operatingCashFlow - Math.abs(input.capex);
+}
+freeCashFlow.formula = "Operating Cash Flow - Capital Expenditures";
+freeCashFlow.description = "Cash available after maintaining/growing asset base. The most important cash flow metric.";
+function fcfYield(input) {
+  return safeDivide(input.freeCashFlow, input.marketCap);
+}
+fcfYield.formula = "Free Cash Flow / Market Capitalization";
+fcfYield.description = "FCF per dollar invested. Inverse of P/FCF. Higher = cheaper.";
+function fcfMargin(input) {
+  return safeDivide(input.freeCashFlow, input.revenue);
+}
+fcfMargin.formula = "Free Cash Flow / Revenue";
+fcfMargin.description = "FCF generated per dollar of revenue.";
+function fcfConversion(input) {
+  return safeDivide(input.freeCashFlow, input.netIncome);
+}
+fcfConversion.formula = "Free Cash Flow / Net Income";
+fcfConversion.description = "FCF conversion > 1 means earnings are backed by real cash. < 1 raises quality concerns.";
+function ocfToSales(input) {
+  return safeDivide(input.operatingCashFlow, input.revenue);
+}
+ocfToSales.formula = "Operating Cash Flow / Revenue";
+ocfToSales.description = "Cash generated from operations per dollar of sales.";
+function capexToRevenue(input) {
+  return safeDivide(Math.abs(input.capex), input.revenue);
+}
+capexToRevenue.formula = "Capital Expenditures / Revenue";
+capexToRevenue.description = "Investment intensity. High in capital-intensive industries like manufacturing.";
+
+// src/ratios/composite/index.ts
+function piotroskiFScore(input) {
+  const { current, prior } = input;
+  const roaCurrent = current.netIncome / current.totalAssets;
+  const roaPrior = prior.netIncome / prior.totalAssets;
+  const leverageCurrent = current.totalAssets > 0 ? current.longTermDebt / current.totalAssets : 0;
+  const leveragePrior = prior.totalAssets > 0 ? prior.longTermDebt / prior.totalAssets : 0;
+  const crCurrent = current.currentLiabilities > 0 ? current.currentAssets / current.currentLiabilities : 0;
+  const crPrior = prior.currentLiabilities > 0 ? prior.currentAssets / prior.currentLiabilities : 0;
+  const gmCurrent = current.revenue > 0 ? current.grossProfit / current.revenue : 0;
+  const gmPrior = prior.revenue > 0 ? prior.grossProfit / prior.revenue : 0;
+  const atCurrent = current.totalAssets > 0 ? current.revenue / current.totalAssets : 0;
+  const atPrior = prior.totalAssets > 0 ? prior.revenue / prior.totalAssets : 0;
+  const signals = {
+    // F1: ROA positive
+    roa_positive: roaCurrent > 0,
+    // F2: Operating cash flow positive
+    ocf_positive: current.operatingCashFlow > 0,
+    // F3: ROA improving year over year
+    roa_improving: roaCurrent > roaPrior,
+    // F4: Accruals — OCF > NI (quality earnings, cash-backed)
+    quality_earnings: current.operatingCashFlow > current.netIncome,
+    // F5: Long-term debt / assets ratio declined
+    lower_leverage: leverageCurrent < leveragePrior,
+    // F6: Current ratio improved
+    higher_liquidity: crCurrent > crPrior,
+    // F7: No new shares issued (dilution)
+    no_dilution: current.sharesOutstanding <= prior.sharesOutstanding,
+    // F8: Gross margin improved
+    higher_gross_margin: gmCurrent > gmPrior,
+    // F9: Asset turnover improved
+    higher_asset_turnover: atCurrent > atPrior
+  };
+  const score = Object.values(signals).filter(Boolean).length;
+  let interpretation = "";
+  if (score >= 8) interpretation = "Strong (8-9): High financial strength, potential value opportunity";
+  else if (score >= 6) interpretation = "Good (6-7): Reasonably healthy fundamentals";
+  else if (score >= 4) interpretation = "Neutral (4-5): Mixed signals, further analysis needed";
+  else interpretation = "Weak (0-3): Multiple red flags, high risk";
+  return { score, signals, interpretation };
+}
+piotroskiFScore.formula = "9 binary signals across Profitability, Leverage/Liquidity, Operating Efficiency";
+piotroskiFScore.description = "F-Score 0-9. >= 8 is strong buy signal. <= 2 is short signal.";
+function altmanZScore(input) {
+  if (input.totalAssets === 0 || input.totalLiabilities === 0) return null;
+  const x1 = input.workingCapital / input.totalAssets;
+  const x2 = input.retainedEarnings / input.totalAssets;
+  const x3 = input.ebit / input.totalAssets;
+  const x4 = input.marketCap / input.totalLiabilities;
+  const x5 = input.revenue / input.totalAssets;
+  const z = 1.2 * x1 + 1.4 * x2 + 3.3 * x3 + 0.6 * x4 + 1 * x5;
+  let zone;
+  let interpretation;
+  if (z > 2.99) {
+    zone = "safe";
+    interpretation = "Safe zone (Z > 2.99): Low probability of bankruptcy";
+  } else if (z > 1.81) {
+    zone = "grey";
+    interpretation = "Grey zone (1.81 < Z < 2.99): Uncertain, monitor closely";
+  } else {
+    zone = "distress";
+    interpretation = "Distress zone (Z < 1.81): High probability of financial distress";
+  }
+  return { z, x1, x2, x3, x4, x5, zone, interpretation };
+}
+altmanZScore.formula = "1.2\xD7X1 + 1.4\xD7X2 + 3.3\xD7X3 + 0.6\xD7X4 + 1.0\xD7X5 (public manufacturing)";
+altmanZScore.description = "Bankruptcy prediction model. Safe > 2.99, Distress < 1.81.";
+
+// src/utils/compute-all.ts
+function g(data, key) {
+  const v = data[key];
+  if (v === void 0 || v === null || typeof v === "object") return 0;
+  return v || 0;
+}
+function computeAll(data) {
+  const result = {};
+  const revenue = g(data, "revenue");
+  const grossProfit = g(data, "grossProfit");
+  const ebit = g(data, "ebit");
+  const ebitda = g(data, "ebitda");
+  const netIncome = g(data, "netIncome");
+  const totalAssets = g(data, "totalAssets");
+  const totalEquity = g(data, "totalEquity");
+  const totalDebt = g(data, "totalDebt");
+  const currentAssets = g(data, "currentAssets");
+  const currentLiabilities = g(data, "currentLiabilities");
+  const cash = g(data, "cash");
+  const accountsReceivable = g(data, "accountsReceivable");
+  const inventory = g(data, "inventory");
+  const marketCap = g(data, "marketCap");
+  const operatingCashFlow = g(data, "operatingCashFlow");
+  const capexRaw = g(data, "capex");
+  const interestExpense = g(data, "interestExpense");
+  const incomeTaxExpense = g(data, "incomeTaxExpense");
+  const ebt = g(data, "ebt");
+  const cogs = g(data, "cogs");
+  const accountsPayable = g(data, "accountsPayable");
+  const retainedEarnings = g(data, "retainedEarnings");
+  const totalLiabilities = g(data, "totalLiabilities");
+  const sharesOutstanding = g(data, "sharesOutstanding");
+  const fcf = freeCashFlow({ operatingCashFlow, capex: capexRaw });
+  const ev = data.enterpriseValue || marketCap + totalDebt - cash || void 0;
+  const taxRate = ebt ? Math.min(Math.max(safeDivide(incomeTaxExpense, ebt) ?? 0.21, 0), 0.5) : 0.21;
+  const nopatVal = nopat({ ebit, taxRate });
+  const icVal = investedCapital({ totalEquity, totalDebt, cash });
+  result.pe = pe({ marketCap, netIncome });
+  result.pb = pb({ marketCap, totalEquity });
+  result.ps = ps({ marketCap, revenue });
+  if (result.pe && data.epsGrowthPct) {
+    result.peg = peg({ peRatio: result.pe, epsGrowthRatePercent: data.epsGrowthPct });
+  }
+  if (operatingCashFlow) result.pFcf = pFcf({ marketCap, operatingCashFlow, capex: capexRaw });
+  result.enterpriseValue = ev ?? null;
+  if (ev && ebitda) result.evEbitda = evEbitda({ enterpriseValue: ev, ebitda });
+  if (ev && ebit) result.evEbit = evEbit({ enterpriseValue: ev, ebit });
+  if (ev && revenue) result.evRevenue = evRevenue({ enterpriseValue: ev, revenue });
+  if (ev && fcf) result.evFcf = evFcf({ enterpriseValue: ev, freeCashFlow: fcf });
+  result.tobinsQ = tobinsQ({ marketCap, totalDebt, totalAssets });
+  if (sharesOutstanding) {
+    const eps = safeDivide(netIncome, sharesOutstanding);
+    const bvps = safeDivide(totalEquity, sharesOutstanding);
+    if (eps && bvps) result.grahamNumber = grahamNumber({ eps, bookValuePerShare: bvps });
+  }
+  result.grossMargin = grossMargin({ grossProfit, revenue });
+  result.operatingMargin = operatingMargin({ ebit, revenue });
+  result.netMargin = netProfitMargin({ netIncome, revenue });
+  if (ebitda) result.ebitdaMargin = ebitdaMargin({ ebitda, revenue });
+  result.roe = roe({ netIncome, avgTotalEquity: totalEquity });
+  result.roa = roa({ netIncome, avgTotalAssets: totalAssets });
+  result.nopat = nopatVal;
+  result.investedCapital = icVal;
+  if (nopatVal && icVal) result.roic = roic({ nopat: nopatVal, investedCapital: icVal });
+  result.roce = roce({ ebit, totalAssets, currentLiabilities });
+  result.freeCashFlow = fcf ?? null;
+  if (fcf) {
+    result.fcfMargin = fcfMargin({ freeCashFlow: fcf, revenue });
+    result.fcfConversion = fcfConversion({ freeCashFlow: fcf, netIncome });
+    if (marketCap) result.fcfYield = fcfYield({ freeCashFlow: fcf, marketCap });
+  }
+  result.ocfToSales = ocfToSales({ operatingCashFlow, revenue });
+  result.capexToRevenue = capexToRevenue({ capex: capexRaw, revenue });
+  result.currentRatio = currentRatio({ currentAssets, currentLiabilities });
+  result.quickRatio = quickRatio({ cash, shortTermInvestments: 0, accountsReceivable, currentLiabilities });
+  result.dso = dso({ accountsReceivable, revenue });
+  if (cogs) {
+    result.dio = dio({ inventory, cogs });
+    result.dpo = dpo({ accountsPayable, cogs });
+  }
+  if (result.dso != null) {
+    result.cashConversionCycle = cashConversionCycle({
+      dso: result.dso,
+      dio: result.dio ?? 0,
+      dpo: result.dpo ?? 0
+    });
+  }
+  result.debtToEquity = debtToEquity({ totalDebt, totalEquity });
+  result.netDebtToEquity = netDebtToEquity({ totalDebt, cash, totalEquity });
+  if (ebitda) result.netDebtToEbitda = netDebtToEbitda({ totalDebt, cash, ebitda });
+  result.debtToAssets = debtToAssets({ totalDebt, totalAssets });
+  result.interestCoverage = interestCoverageRatio({ ebit, interestExpense });
+  result.equityMultiplier = equityMultiplier({ totalAssets, totalEquity });
+  result.assetTurnover = assetTurnover({ revenue, avgTotalAssets: totalAssets });
+  result.receivablesTurnover = receivablesTurnover({ revenue, avgAccountsReceivable: accountsReceivable });
+  if (cogs) {
+    result.inventoryTurnover = inventoryTurnover({ cogs, avgInventory: inventory });
+    result.payablesTurnover = payablesTurnover({ cogs, avgAccountsPayable: accountsPayable });
+  }
+  if (totalAssets && totalLiabilities) {
+    result.altmanZ = altmanZScore({
+      workingCapital: currentAssets - currentLiabilities,
+      retainedEarnings,
+      ebit,
+      marketCap,
+      totalLiabilities,
+      totalAssets,
+      revenue
+    });
+  }
+  if (data.prior) {
+    const p = data.prior;
+    const pGet = (key) => {
+      const v = p[key];
+      return (typeof v === "number" ? v : 0) || 0;
+    };
+    try {
+      result.piotroski = piotroskiFScore({
+        current: {
+          netIncome,
+          totalAssets,
+          operatingCashFlow,
+          longTermDebt: g(data, "longTermDebt"),
+          currentAssets,
+          currentLiabilities,
+          sharesOutstanding,
+          grossProfit,
+          revenue
+        },
+        prior: {
+          netIncome: pGet("netIncome"),
+          totalAssets: pGet("totalAssets"),
+          longTermDebt: pGet("longTermDebt"),
+          currentAssets: pGet("currentAssets"),
+          currentLiabilities: pGet("currentLiabilities"),
+          sharesOutstanding: pGet("sharesOutstanding"),
+          grossProfit: pGet("grossProfit"),
+          revenue: pGet("revenue")
+        }
+      });
+    } catch {
+      result.piotroski = null;
+    }
+  }
+  return result;
+}
+
+// src/utils/scenario-dcf.ts
+var DEFAULT_SCENARIOS = {
+  bear: { growthRate: 0.03, wacc: 0.12, terminalGrowth: 0.02, years: 10 },
+  base: { growthRate: 0.07, wacc: 0.09, terminalGrowth: 0.02, years: 10 },
+  bull: { growthRate: 0.12, wacc: 0.08, terminalGrowth: 0.03, years: 10 }
+};
+function scenarioDcf(input) {
+  const {
+    baseFcf,
+    sharesOutstanding,
+    currentPrice,
+    scenarios = DEFAULT_SCENARIOS
+  } = input;
+  const result = {};
+  for (const [name, params] of Object.entries(scenarios)) {
+    const growthRate = params.growthRate ?? 0.07;
+    const wacc = params.wacc ?? 0.09;
+    const terminalGrowth = params.terminalGrowth ?? 0.02;
+    const years = params.years ?? 10;
+    let fcf = baseFcf;
+    let pvSum = 0;
+    for (let t = 1; t <= years; t++) {
+      fcf = fcf * (1 + growthRate);
+      pvSum += fcf / Math.pow(1 + wacc, t);
+    }
+    let terminalValue = 0;
+    if (wacc > terminalGrowth) {
+      const terminalFcf = fcf * (1 + terminalGrowth);
+      terminalValue = terminalFcf / (wacc - terminalGrowth);
+    }
+    const pvTerminal = terminalValue / Math.pow(1 + wacc, years);
+    const intrinsicValue = pvSum + pvTerminal;
+    const intrinsicValuePerShare = safeDivide(intrinsicValue, sharesOutstanding) ?? null;
+    let upsidePct = null;
+    if (currentPrice && currentPrice > 0 && intrinsicValuePerShare !== null) {
+      upsidePct = (intrinsicValuePerShare - currentPrice) / currentPrice;
+    }
+    result[name] = {
+      intrinsicValue,
+      intrinsicValuePerShare,
+      pvFcfs: pvSum,
+      pvTerminal,
+      terminalValue,
+      upsidePct,
+      params: { growthRate, wacc, terminalGrowth, years }
+    };
+  }
+  return result;
+}
+
+// src/hooks/index.ts
+function useRatios(ticker, fetcher) {
+  const [state, setState] = react.useState({
+    data: null,
+    loading: false,
+    error: null,
+    refetch: () => {
+    }
+  });
+  const fetcherRef = react.useRef(fetcher);
+  fetcherRef.current = fetcher;
+  const fetch = react.useCallback(() => {
+    if (!ticker) return;
+    setState((s) => ({ ...s, loading: true, error: null }));
+    fetcherRef.current(ticker).then((raw) => {
+      const ratios = computeAll(raw);
+      setState({ data: ratios, loading: false, error: null, refetch: fetch });
+    }).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      setState((s) => ({ ...s, loading: false, error: message }));
+    });
+  }, [ticker]);
+  react.useEffect(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+function useRatio(ticker, ratio, fetcher) {
+  const ratiosState = useRatios(ticker, fetcher);
+  return {
+    data: ratiosState.data ? ratiosState.data[ratio] ?? null : null,
+    loading: ratiosState.loading,
+    error: ratiosState.error,
+    refetch: ratiosState.refetch
+  };
+}
+function useHealthScore(ticker, fetcher, scoreFn) {
+  const ratiosState = useRatios(ticker, fetcher);
+  const score = ratiosState.data ? scoreFn(ratiosState.data) : null;
+  return {
+    data: score,
+    loading: ratiosState.loading,
+    error: ratiosState.error,
+    refetch: ratiosState.refetch
+  };
+}
+function useScenarioDcf(input) {
+  const [data, setData] = react.useState(null);
+  react.useEffect(() => {
+    if (!input) {
+      setData(null);
+      return;
+    }
+    setData(scenarioDcf(input));
+  }, [
+    input?.baseFcf,
+    input?.sharesOutstanding,
+    input?.currentPrice
+  ]);
+  return { data };
+}
+function useCompareRatios(tickers, fetcher) {
+  const [state, setState] = react.useState({
+    data: null,
+    loading: false,
+    error: null,
+    refetch: () => {
+    }
+  });
+  const fetcherRef = react.useRef(fetcher);
+  fetcherRef.current = fetcher;
+  const tickersKey = tickers.join(",");
+  const fetch = react.useCallback(() => {
+    if (!tickers.length) return;
+    setState((s) => ({ ...s, loading: true, error: null }));
+    Promise.allSettled(tickers.map((t) => fetcherRef.current(t).then((raw) => [t, computeAll(raw)]))).then((results) => {
+      const data = {};
+      for (const result of results) {
+        if (result.status === "fulfilled") {
+          const [ticker, ratios] = result.value;
+          data[ticker] = ratios;
+        }
+      }
+      setState({ data, loading: false, error: null, refetch: fetch });
+    }).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      setState((s) => ({ ...s, loading: false, error: message }));
+    });
+  }, [tickersKey]);
+  react.useEffect(() => {
+    fetch();
+  }, [fetch]);
+  return { ...state, refetch: fetch };
+}
+
+exports.useCompareRatios = useCompareRatios;
+exports.useHealthScore = useHealthScore;
+exports.useRatio = useRatio;
+exports.useRatios = useRatios;
+exports.useScenarioDcf = useScenarioDcf;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map