Files
Investidor-V2/resources/js/lib/business-plan-guidance.ts
T

296 lines
10 KiB
TypeScript

export type PlanWarningLimits = {
grossMarginPercent: number;
cashExpenseMonths: number;
annualGrowthPercent: number;
creditDays: number;
debtAssetsPercent: number;
};
export const defaultPlanWarningLimits: PlanWarningLimits = {
grossMarginPercent: 15,
cashExpenseMonths: 1,
annualGrowthPercent: 100,
creditDays: 90,
debtAssetsPercent: 70,
};
export type PlanWarning = { id: string; message: string };
export type PlanWarningMetrics = {
fundingGap?: number;
currency?: string;
netProfit?: number;
sales?: number;
directCosts?: number;
monthlyBreakEven?: number | null;
monthlyExpenses?: number;
cash?: number;
growthPercent?: number;
creditDays?: number;
liabilities?: number;
assets?: number;
ownAndInvestorCapital?: number;
};
/** Guidance only: warnings never change the inputs or determine validity. */
export function businessPlanWarnings(
metrics: PlanWarningMetrics,
limits: PlanWarningLimits = defaultPlanWarningLimits,
): PlanWarning[] {
const warnings: PlanWarning[] = [];
const add = (id: string, message: string) => warnings.push({ id, message });
if ((metrics.fundingGap ?? 0) > 0)
add(
'funding',
`O financiamento indicado não cobre o investimento necessário. Faltam ${metrics.fundingGap!.toLocaleString('pt-MZ', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}${metrics.currency ? ` ${metrics.currency}` : ''}.`,
);
if (metrics.netProfit !== undefined && metrics.netProfit < 0)
add(
'loss',
'Neste ano o negócio dá prejuízo. Reveja as vendas ou os custos, ou confirme que é o esperado.',
);
if (
metrics.sales !== undefined &&
metrics.sales > 0 &&
metrics.directCosts !== undefined
) {
if (
(100 * (metrics.sales - metrics.directCosts)) / metrics.sales <
limits.grossMarginPercent
)
add(
'margin',
'A margem bruta é baixa e deixa pouca folga para cobrir as despesas.',
);
if (
metrics.monthlyBreakEven != null &&
metrics.monthlyBreakEven > metrics.sales / 12
)
add(
'break-even',
'As vendas mensais médias não atingem o ponto de equilíbrio. O negócio só cobre os custos com mais vendas.',
);
}
if (
metrics.cash !== undefined &&
metrics.monthlyExpenses !== undefined &&
metrics.cash < metrics.monthlyExpenses * limits.cashExpenseMonths
)
add(
'cash',
'A caixa disponível cobre menos de um mês de despesas. Considere reforçar o financiamento.',
);
if (
metrics.growthPercent !== undefined &&
metrics.growthPercent > limits.annualGrowthPercent
)
add(
'growth',
'O crescimento indicado é muito elevado. Confirme que é realista.',
);
if (
metrics.creditDays !== undefined &&
metrics.creditDays > limits.creditDays
)
add(
'credit',
'Prazos de recebimento longos pressionam a caixa. Confirme o prazo indicado.',
);
if (
metrics.assets !== undefined &&
metrics.assets > 0 &&
metrics.liabilities !== undefined &&
(metrics.liabilities / metrics.assets) * 100 > limits.debtAssetsPercent
)
add(
'debt',
'O peso das dívidas é elevado e pode dificultar o acesso a crédito.',
);
if (metrics.ownAndInvestorCapital === 0)
add(
'capital',
'Não indicou capital próprio nem de investidor. Todo o financiamento vem de empréstimos ou fica por definir.',
);
return warnings;
}
export type AnnualReferencePlan = {
startupExpenses: { label: string; amount: string }[];
openingCash: string;
otherCurrentAssets: string;
longTermAssets: string;
ownerCapital: string;
investorCapital: string;
loans: string;
additionalMoney: string;
years: {
year: number;
sales: string;
directCosts: string;
payroll: string;
payrollCharges: string;
otherOperatingExpenses: string;
interest: string;
taxes: string;
cashReceived: string;
cashSpent: string;
}[];
};
/** Values explicitly supplied by the owner; currency must be chosen in the form. */
export function newAnnualReferencePlan(): AnnualReferencePlan {
return {
startupExpenses: [
{ label: 'Constituição da sociedade', amount: '25000' },
{ label: 'Material de escritório', amount: '50000' },
{ label: 'Seguros', amount: '0' },
{ label: 'Rendas', amount: '0' },
{ label: 'Computadores', amount: '250000' },
{ label: 'Desenvolvimento do portal', amount: '1000000' },
],
openingCash: '90000',
otherCurrentAssets: '150000',
longTermAssets: '260250',
ownerCapital: '0',
investorCapital: '0',
loans: '0',
additionalMoney: '0',
years: [
{
year: 2025,
sales: '14537',
directCosts: '12538',
payroll: '2100',
payrollCharges: '315',
otherOperatingExpenses: '0',
interest: '0',
taxes: '0',
cashReceived: '16539',
cashSpent: '15783',
},
{
year: 2026,
sales: '21500',
directCosts: '16200',
payroll: '2800',
payrollCharges: '420',
otherOperatingExpenses: '0',
interest: '0',
taxes: '624',
cashReceived: '24930',
cashSpent: '23923',
},
{
year: 2027,
sales: '23875',
directCosts: '18325',
payroll: '2800',
payrollCharges: '420',
otherOperatingExpenses: '0',
interest: '0',
taxes: '699',
cashReceived: '27857',
cashSpent: '26122',
},
],
};
}
function money(value: string): bigint {
if (value.length > 40 || !/^\d+(?:\.\d{1,2})?$/.test(value.trim()))
throw new Error(
value.trim() === ''
? 'Preencha este campo para continuar.'
: Number(value) < 0
? 'Este valor não pode ser negativo.'
: 'Introduza apenas números (ex.: 25.000).',
);
const [whole, fraction = ''] = value.trim().split('.');
return BigInt(whole) * 100n + BigInt(fraction.padEnd(2, '0'));
}
function decimal(value: bigint): string {
const abs = value < 0n ? -value : value;
return `${value < 0n ? '-' : ''}${abs / 100n}.${String(abs % 100n).padStart(2, '0')}`;
}
export function calculateAnnualReferencePlan(plan: AnnualReferencePlan) {
const startupExpenses = plan.startupExpenses.reduce(
(sum, row) => sum + money(row.amount),
0n,
);
const openingCash = money(plan.openingCash);
const assets =
openingCash +
money(plan.otherCurrentAssets) +
money(plan.longTermAssets);
const requiredFunding = startupExpenses + assets;
const availableFunding =
money(plan.ownerCapital) +
money(plan.investorCapital) +
money(plan.loans) +
money(plan.additionalMoney);
let cash = openingCash;
const years = plan.years.map((year, index) => {
const sales = money(year.sales),
costs = money(year.directCosts);
if (sales === 0n && costs > 0n)
throw new Error(
'Indique as vendas previstas para calcular a margem e o ponto de equilíbrio.',
);
if (sales > 0n && costs >= sales)
throw new Error(
'Com este custo variável não há margem para cobrir os custos fixos. Reveja o custo variável ou o preço.',
);
const grossMargin = sales - costs;
const operatingExpenses =
money(year.payroll) +
money(year.payrollCharges) +
money(year.otherOperatingExpenses);
const operatingProfit = grossMargin - operatingExpenses;
const netProfit =
operatingProfit - money(year.interest) - money(year.taxes);
const cashFlow = money(year.cashReceived) - money(year.cashSpent);
cash += cashFlow;
// Keep the unrounded gross-margin fraction in the break-even formula.
const monthlyBreakEven =
grossMargin > 0n
? (Number(operatingExpenses) * Number(sales)) /
(1200 * Number(grossMargin))
: null;
const previousSales =
index > 0 ? money(plan.years[index - 1].sales) : null;
const growthPercent =
previousSales !== null && previousSales > 0n
? (Number(sales - previousSales) / Number(previousSales)) * 100
: null;
return {
year: year.year,
sales: decimal(sales),
directCosts: decimal(costs),
grossMargin: decimal(grossMargin),
grossMarginPercent:
sales > 0n ? (Number(grossMargin) / Number(sales)) * 100 : null,
operatingExpenses: decimal(operatingExpenses),
operatingProfit: decimal(operatingProfit),
netProfit: decimal(netProfit),
netMarginPercent:
sales > 0n ? (Number(netProfit) / Number(sales)) * 100 : null,
cashFlow: decimal(cashFlow),
closingCash: decimal(cash),
monthlyFixedCosts: Number(operatingExpenses) / 1200,
monthlyBreakEven,
growthPercent,
};
});
return {
startupExpenses: decimal(startupExpenses),
assets: decimal(assets),
requiredFunding: decimal(requiredFunding),
availableFunding: decimal(availableFunding),
fundingGap: decimal(
requiredFunding > availableFunding
? requiredFunding - availableFunding
: 0n,
),
years,
monthlyStatus: 'por reconciliar' as const,
};
}