Files
Investidor-V2/resources/js/components/simulation-annual-example.tsx
T

424 lines
21 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import {
calculateAnnualReferencePlan,
newAnnualReferencePlan,
restoreAnnualExampleSnapshot,
serializeAnnualExampleSnapshot,
type AnnualReferencePlan,
} from '@/lib/business-plan-guidance';
import { businessPlanNumberError } from '@/lib/business-financial-plan';
import { BusinessPlanWarnings } from './business-plan-warnings';
const annualLabels = {
sales: 'Vendas previstas',
directCosts: 'Custo directo das vendas',
payroll: 'Folha de pagamento',
payrollCharges: 'Encargos da folha de pagamento',
otherOperatingExpenses: 'Outras despesas operacionais',
interest: 'Juros',
taxes: 'Impostos estimados do exemplo',
cashReceived: 'Caixa recebida',
cashSpent: 'Caixa gasta',
vatReceived: 'IVA incluído nos recebimentos (montante do exemplo)',
vatPaid: 'IVA incluído nos pagamentos (montante do exemplo)',
} as const;
const openingLabels = {
openingCash: 'Caixa necessária',
otherCurrentAssets: 'Outros activos correntes',
longTermAssets: 'Activos de longo prazo',
ownerCapital: 'Capital do proprietário disponível',
investorCapital: 'Capital do investidor disponível',
loans: 'Empréstimos disponíveis',
additionalMoney: 'Dinheiro adicional angariado',
} as const;
function ExampleNumber({
label,
value,
onChange,
}: {
label: string;
value: string;
onChange: (value: string) => void;
}) {
const error = businessPlanNumberError(value);
return (
<label className="grid gap-1 text-sm">
{label}
<input
type="number"
min="0"
step="0.01"
className="min-w-0 rounded border p-2"
value={value}
aria-invalid={!!error}
onChange={(event) => onChange(event.target.value)}
/>
{error && (
<span role="alert" className="text-red-800">
{error}
</span>
)}
</label>
);
}
export function SimulationAnnualExample({
currency,
snapshot,
onSnapshotChange,
}: {
currency: string;
snapshot?: string;
onSnapshotChange?: (snapshot: string) => void;
}) {
const recovered = restoreAnnualExampleSnapshot(snapshot);
if (snapshot && !recovered)
return (
<p role="alert">
Não foi possível recuperar o cenário de exemplo. O conteúdo
guardado foi preservado; não será substituído.
</p>
);
const plan = recovered ?? newAnnualReferencePlan();
const setPlan = (
update: (previous: AnnualReferencePlan) => AnnualReferencePlan,
) => {
onSnapshotChange?.(serializeAnnualExampleSnapshot(update(plan)));
};
let result: ReturnType<typeof calculateAnnualReferencePlan> | undefined;
let error = '';
try {
result = calculateAnnualReferencePlan(plan);
} catch (cause) {
error =
cause instanceof Error
? cause.message
: 'Reveja os campos do exemplo.';
}
const amount = (value: string | number | null) =>
value === null
? 'Por determinar'
: Number(value).toLocaleString('pt-MZ', {
minimumFractionDigits: 2,
maximumFractionDigits: 2,
});
return (
<section
aria-label="Cenário anual de exemplo"
className="my-4 space-y-4 rounded border border-sky-400 bg-sky-50 p-4"
>
<h4 className="text-lg font-semibold">
Cenário anual de exemplo — editável
</h4>
<p className="text-sm">
Dados sintéticos de demonstração, com totais do plano de
referência e projecções ilustrativas. Moeda de apresentação:{' '}
{currency || 'por seleccionar no plano'}. As edições deste
ensaio acompanham o rascunho do simulador numa secção separada.
Sem sessão, retome no mesmo navegador; com sessão autenticada,
utilize o rascunho da sua conta para retomar noutro dispositivo.
Estes valores não substituem os dados reais do investimento.
</p>
<p className="rounded border border-amber-400 p-3 text-sm">
Linhas mensais por reconciliar. Conservam-se os totais anuais
definidos pelo proprietário; não se distribuem valores pelos
meses da fonte nem se completam as suas linhas em falta. A
projecção mensal ilustrativa abaixo é um cálculo separado. Os
impostos são montantes do exemplo, sem activar taxas fiscais.
</p>
<details open>
<summary className="font-semibold">
Despesas e activos iniciais
</summary>
<div className="mt-3 grid gap-3 sm:grid-cols-2 lg:grid-cols-3">
{plan.startupExpenses.map((row, index) => (
<ExampleNumber
key={row.label}
label={row.label}
value={row.amount}
onChange={(value) =>
setPlan((previous) => ({
...previous,
startupExpenses:
previous.startupExpenses.map(
(entry, i) =>
i === index
? {
...entry,
amount: value,
}
: entry,
),
}))
}
/>
))}
{Object.entries(openingLabels).map(([key, label]) => (
<ExampleNumber
key={key}
label={label}
value={plan[key as keyof typeof openingLabels]}
onChange={(value) =>
setPlan((previous) => ({
...previous,
[key]: value,
}))
}
/>
))}
</div>
</details>
{plan.years.map((year, index) => (
<details key={year.year}>
<summary className="font-semibold">
Pressupostos anuais — {year.year}
</summary>
<div className="mt-3 grid gap-3 sm:grid-cols-2 lg:grid-cols-3">
{Object.entries(annualLabels).map(([key, label]) => (
<ExampleNumber
key={key}
label={label}
value={year[key as keyof typeof annualLabels]}
onChange={(value) =>
setPlan((previous) => ({
...previous,
years: previous.years.map((entry, i) =>
i === index
? { ...entry, [key]: value }
: entry,
),
}))
}
/>
))}
</div>
</details>
))}
{error && (
<p
role="alert"
className="rounded border border-red-400 bg-red-50 p-3 text-red-900"
>
{error} Os valores introduzidos permanecem nos campos.
</p>
)}
{result && (
<>
<dl className="grid gap-3 sm:grid-cols-2">
{[
[
'Despesas totais de arranque',
result.startupExpenses,
],
['Total de activos iniciais', result.assets],
[
'Financiamento total requerido',
result.requiredFunding,
],
[
'Financiamento disponível',
result.availableFunding,
],
].map(([label, value]) => (
<div key={label}>
<dt>{label}</dt>
<dd className="font-semibold">
{amount(value)} {currency}
</dd>
</div>
))}
</dl>
<div className="overflow-x-auto">
<table className="w-full text-left text-sm">
<caption className="py-2 text-left font-semibold">
Resultados anuais do exemplo{' '}
{currency && `(${currency})`}
</caption>
<thead>
<tr>
<th>Resultado</th>
{result.years.map((year) => (
<th key={year.year}>{year.year}</th>
))}
</tr>
</thead>
<tbody>
{(
[
'sales',
'directCosts',
'grossMargin',
'grossMarginPercent',
'operatingExpenses',
'operatingProfit',
'netProfit',
'monthlyFixedCosts',
'monthlyBreakEven',
'cashFlow',
'closingCash',
] as const
).map((key) => (
<tr key={key}>
<th className="py-1 font-medium">
{
{
sales: 'Vendas',
directCosts:
'Custo directo das vendas',
grossMargin: 'Margem bruta',
grossMarginPercent:
'Margem bruta (%)',
operatingExpenses:
'Despesas operacionais',
operatingProfit:
'Lucro antes de juros e impostos',
netProfit: 'Lucro líquido',
monthlyFixedCosts:
'Custo fixo mensal estimado',
monthlyBreakEven:
'Ponto de equilíbrio mensal',
cashFlow:
'Fluxo líquido de caixa',
closingCash:
'Saldo de caixa',
}[key]
}
</th>
{result.years.map((year) => (
<td key={year.year}>
{amount(year[key])}
</td>
))}
</tr>
))}
</tbody>
</table>
</div>
{result.years.map((year, index) => (
<div key={year.year}>
<p>
Balanço projectado: activos{' '}
{amount(year.closingAssets)}, passivos{' '}
{amount(year.closingLiabilities)} e capital{' '}
{amount(year.closingCapital)}. Diferença:{' '}
{amount(year.balanceDifference)} {currency}.
Valores a receber: {amount(year.receivables)};
obrigações operacionais:{' '}
{amount(year.operatingLiabilities)}.
</p>
<details>
<summary>
Distribuição mensal ilustrativa —{' '}
{year.year}
</summary>
<p>
Esta simulação distribui os totais anuais
pelo perfil sazonal agregado do exemplo.
Despesas fixas são repartidas por igual;
recebimentos e pagamentos sem IVA seguem
vendas e despesas, respectivamente. Os
centavos remanescentes são distribuídos
pelas maiores fracções. Não representa
recuperação dos meses da referência.
</p>
<div className="overflow-x-auto">
<table className="w-full text-left text-sm">
<caption>
Projecção mensal ({currency})
</caption>
<thead>
<tr>
{[
'Mês',
'Vendas',
'Custos directos',
'Lucro líquido',
'Recebimentos',
'Pagamentos',
'Caixa',
'Diferença do balanço',
].map((label) => (
<th key={label}>{label}</th>
))}
</tr>
</thead>
<tbody>
{year.illustrativeMonths.map(
(month) => (
<tr key={month.month}>
<th>{month.month}</th>
{(
[
'sales',
'directCosts',
'netProfit',
'cashReceived',
'cashSpent',
'closingCash',
'balanceDifference',
] as const
).map((key) => (
<td key={key}>
{amount(
month[key],
)}
</td>
))}
</tr>
),
)}
</tbody>
</table>
</div>
</details>
<h5 className="font-semibold">
Avisos — {year.year}
</h5>
<BusinessPlanWarnings
metrics={{
currency,
fundingGap:
index === 0
? Number(result.fundingGap)
: undefined,
netProfit: Number(year.netProfit),
sales: Number(year.sales),
directCosts: Number(year.directCosts),
monthlyBreakEven: year.monthlyBreakEven,
monthlyExpenses:
Number(year.operatingExpenses) / 12,
cash: Number(year.closingCash),
growthPercent:
year.growthPercent ?? undefined,
ownAndInvestorCapital:
index === 0
? Number(plan.ownerCapital) +
Number(plan.investorCapital)
: undefined,
}}
/>
</div>
))}
<p className="text-sm">
O balanço pressupõe mobilizar{' '}
{amount(result.capitalToMobilise)} {currency} de capital
ainda em falta. Não é financiamento confirmado. Os
saldos iniciais a receber e de obrigações operacionais
são zero neste cenário; activos e empréstimos mantêm-se
constantes. As obrigações incluem custos, despesas,
juros e impostos reconhecidos e ainda não pagos. Os
montantes de IVA são dados do exemplo, sem inferência de
taxas fiscais.
</p>
<p className="text-sm">
Margem bruta = vendas − custo directo. Lucro líquido =
margem bruta − despesas operacionais − juros − impostos.
Ponto de equilíbrio = (despesas operacionais ÷ 12) ÷
(margem bruta ÷ vendas), sem arredondar os valores
intermédios. Caixa final = caixa anterior + recebimentos
− pagamentos.
</p>
</>
)}
</section>
);
}