) : null}
+ {view.leverage ? (
+
+ Alavancagem da chapa:{' '}
+
+ {view.leverage.weightedPercent}%
+ {' '}
+ da base {formatMajoritarianTicketBaseLabel()}
+ {view.leverage.unconvertedCount > 0 ? (
+ <>
+ {' · '}
+
+ {formatElectionNumber(view.leverage.unconvertedCount)} com base não convertida
+
+
+ ) : null}
+
+ ) : null}
+ {view.flipOpportunity && view.flipOpportunity.count > 0 ? (
+
+ Oportunidade de completar a chapa:{' '}
+
+ {formatElectionNumber(view.flipOpportunity.count)}{' '}
+ {view.flipOpportunity.count === 1 ? 'núcleo' : 'núcleos'}
+
+ {view.flipOpportunity.bothAlignedCount > 0 ? (
+ <>
+ {' · '}
+
+ {formatElectionNumber(view.flipOpportunity.bothAlignedCount)} com majoritários
+ alinhados
+
+
+ ) : null}
+
+ ) : null}
diff --git a/src/lib/electionInsights.ts b/src/lib/electionInsights.ts
index 8fc70e42..204853a3 100644
--- a/src/lib/electionInsights.ts
+++ b/src/lib/electionInsights.ts
@@ -1,4 +1,5 @@
import { BASELINE_TICKET_2022 } from '@/lib/electionResults'
+import { partySpectrum } from '@/lib/electionPartySpectrum'
export const NO_ELECTION_BASELINE_MESSAGE =
'Sem baseline TSE (informe território/município)' as const
@@ -12,6 +13,9 @@ export const CONVERSION_OPPORTUNITY_MAX = 0.15
/** At or above this share of aptos → stronghold (literature reference, A5). */
export const CONVERSION_REDUTO_MIN = 0.4
+/** Share of federal nominal votes outside the chapa field → flip opportunity (A5 Fase 2). */
+export const RIGHT_SHARE_THRESHOLD = 0.25
+
export type VoteTrendStatus = 'decline' | 'stable' | 'increase' | 'noBaseline'
export type VoteTrendSeries = {
@@ -335,3 +339,330 @@ export const computeConversionRate = ({
supportLine,
}
}
+
+export type TicketLeverageStatus =
+ | 'comparable'
+ | 'noEstimate'
+ | 'noBaseline'
+ | 'noTicketVotes'
+
+export type TicketLeverageInput = {
+ confirmedVoteEstimate: number | null
+ presidentVotes: number | null
+ governorVotes: number | null
+}
+
+export type TicketLeverageResult = {
+ headlinePercent: number | null
+ /** Stronger majoritarian base used for the headline ratio (comparable only). */
+ ticketVotes: number | null
+ status: TicketLeverageStatus
+ message: string
+ supportLine: string | null
+}
+
+export type MajoritarianWinner = {
+ name: string
+ party: string
+ votes: number
+} | null
+
+export type TicketFlipTrigger = 'winner' | 'share' | 'both'
+
+export type MajoritarianAlignment = 'president' | 'governor' | 'both'
+
+export type TicketFlipStatus =
+ | 'opportunity'
+ | 'noOpportunity'
+ | 'ambiguous'
+ | 'unknownSpectrum'
+ | 'incomplete'
+
+export type TicketFlipOpportunityInput = {
+ winnerPresident: MajoritarianWinner
+ winnerGovernor: MajoritarianWinner
+ winnerFederal: MajoritarianWinner
+ federalVotesByParty: Readonly>
+}
+
+export type TicketFlipOpportunityResult = {
+ status: TicketFlipStatus
+ trigger: TicketFlipTrigger | null
+ majoritarianAlignment: MajoritarianAlignment | null
+ rightShare: number | null
+ rightVotes: number
+ totalFederalVotes: number
+ message: string
+ supportLine: string | null
+}
+
+export type TicketLeverageOverviewAggregate = {
+ weightedPercent: number
+ unconvertedCount: number
+}
+
+export type TicketFlipOverviewAggregate = {
+ count: number
+ bothAlignedCount: number
+}
+
+const formatPercent = (ratio: number): number => Math.round(ratio * 100)
+
+/** User-facing label for the configured majoritarian ticket base (cycle-specific names). */
+export const formatMajoritarianTicketBaseLabel = (): string =>
+ `${BASELINE_TICKET_2022.president.name}/${BASELINE_TICKET_2022.governor.name.split(' ')[0]}`
+
+const MAJORITARIAN_ALIGNMENT_MESSAGE_PREFIX: Record = {
+ both: 'Majoritários alinhados. ',
+ president: 'Presidente alinhado. ',
+ governor: 'Governador alinhado. ',
+}
+
+const ticketLeverageUnavailable = (
+ status: Exclude,
+ message: string,
+): TicketLeverageResult => ({
+ headlinePercent: null,
+ ticketVotes: null,
+ status,
+ message,
+ supportLine: null,
+})
+
+/**
+ * Fase 1 — how much of the president/governor majoritarian base the confirmed estimate captures.
+ */
+export const computeTicketLeverage = ({
+ confirmedVoteEstimate,
+ presidentVotes,
+ governorVotes,
+}: TicketLeverageInput): TicketLeverageResult => {
+ if (presidentVotes === null && governorVotes === null) {
+ return ticketLeverageUnavailable('noBaseline', NO_ELECTION_BASELINE_MESSAGE)
+ }
+
+ if (confirmedVoteEstimate === null) {
+ return ticketLeverageUnavailable(
+ 'noEstimate',
+ 'Sem estimativa confirmada para calcular a alavancagem',
+ )
+ }
+
+ const presidentVoteTotal = presidentVotes ?? 0
+ const governorVoteTotal = governorVotes ?? 0
+ const ticketVotes = Math.max(presidentVoteTotal, governorVoteTotal)
+
+ if (ticketVotes <= 0) {
+ return ticketLeverageUnavailable(
+ 'noTicketVotes',
+ 'Sem votos da chapa majoritária nesta geografia em 2022',
+ )
+ }
+
+ const headlineRatio = confirmedVoteEstimate / ticketVotes
+ const headlinePercent = formatPercent(headlineRatio)
+
+ const unconverted = headlineRatio < 1
+ const supportParts: string[] = []
+ if (presidentVoteTotal > 0) {
+ supportParts.push(
+ `${BASELINE_TICKET_2022.president.name}: ${formatPercent(confirmedVoteEstimate / presidentVoteTotal)}% (${formatElectionNumber(confirmedVoteEstimate)} / ${formatElectionNumber(presidentVoteTotal)})`,
+ )
+ }
+ if (governorVoteTotal > 0) {
+ supportParts.push(
+ `${BASELINE_TICKET_2022.governor.name}: ${formatPercent(confirmedVoteEstimate / governorVoteTotal)}% (${formatElectionNumber(confirmedVoteEstimate)} / ${formatElectionNumber(governorVoteTotal)})`,
+ )
+ }
+
+ const ticketBaseLabel = formatMajoritarianTicketBaseLabel()
+
+ return {
+ headlinePercent,
+ ticketVotes,
+ status: 'comparable',
+ message: `Alavancagem da chapa: ${headlinePercent}%`,
+ supportLine: unconverted
+ ? `Da base ${ticketBaseLabel} ainda não convertida${supportParts.length ? ` · ${supportParts.join(' · ')}` : ''}`
+ : supportParts.join(' · ') || null,
+ }
+}
+
+export const isComparableTicketLeverage = (status: TicketLeverageStatus): status is 'comparable' =>
+ status === 'comparable'
+
+const sumRightFederalVotes = (
+ federalVotesByParty: Readonly>,
+): { rightVotes: number; totalVotes: number; hasUnknownParty: boolean } => {
+ let rightVotes = 0
+ let totalVotes = 0
+ let hasUnknownParty = false
+
+ for (const [party, votes] of Object.entries(federalVotesByParty)) {
+ if (votes <= 0) continue
+ totalVotes += votes
+ const spectrum = partySpectrum(party)
+ if (spectrum === null) {
+ hasUnknownParty = true
+ continue
+ }
+ if (spectrum === 'direita') rightVotes += votes
+ }
+
+ return { rightVotes, totalVotes, hasUnknownParty }
+}
+
+const resolveMajoritarianAlignment = (
+ winnerPresident: MajoritarianWinner,
+ winnerGovernor: MajoritarianWinner,
+): MajoritarianAlignment | null => {
+ const presidentLeft = winnerPresident ? partySpectrum(winnerPresident.party) === 'esquerda' : false
+ const governorLeft = winnerGovernor ? partySpectrum(winnerGovernor.party) === 'esquerda' : false
+
+ if (presidentLeft && governorLeft) return 'both'
+ if (presidentLeft) return 'president'
+ if (governorLeft) return 'governor'
+ return null
+}
+
+/**
+ * Fase 2 — majoritarian left alignment + federal proportional still outside the chapa field.
+ */
+export const computeTicketFlipOpportunity = ({
+ winnerPresident,
+ winnerGovernor,
+ winnerFederal,
+ federalVotesByParty,
+}: TicketFlipOpportunityInput): TicketFlipOpportunityResult => {
+ const majoritarianAlignment = resolveMajoritarianAlignment(winnerPresident, winnerGovernor)
+
+ if (!majoritarianAlignment) {
+ return {
+ status: 'incomplete',
+ trigger: null,
+ majoritarianAlignment: null,
+ rightShare: null,
+ rightVotes: 0,
+ totalFederalVotes: 0,
+ message: 'Sem alinhamento majoritário de esquerda nesta geografia',
+ supportLine: null,
+ }
+ }
+
+ const { rightVotes, totalVotes, hasUnknownParty } = sumRightFederalVotes(federalVotesByParty)
+
+ if (totalVotes <= 0) {
+ return {
+ status: 'incomplete',
+ trigger: null,
+ majoritarianAlignment,
+ rightShare: null,
+ rightVotes: 0,
+ totalFederalVotes: 0,
+ message: 'Sem votos nominais federais nesta geografia',
+ supportLine: null,
+ }
+ }
+
+ if (hasUnknownParty) {
+ return {
+ status: 'unknownSpectrum',
+ trigger: null,
+ majoritarianAlignment,
+ rightShare: rightVotes / totalVotes,
+ rightVotes,
+ totalFederalVotes: totalVotes,
+ message: 'Espectro partidário incompleto para avaliar oportunidade',
+ supportLine: null,
+ }
+ }
+
+ const rightShare = rightVotes / totalVotes
+ const triggerWinner =
+ winnerFederal !== null && partySpectrum(winnerFederal.party) === 'direita'
+ const triggerShare = rightShare >= RIGHT_SHARE_THRESHOLD
+
+ if (!triggerWinner && !triggerShare) {
+ return {
+ status: 'noOpportunity',
+ trigger: null,
+ majoritarianAlignment,
+ rightShare,
+ rightVotes,
+ totalFederalVotes: totalVotes,
+ message: 'Sem oportunidade de completar a chapa neste território',
+ supportLine: null,
+ }
+ }
+
+ const trigger: TicketFlipTrigger =
+ triggerWinner && triggerShare ? 'both' : triggerWinner ? 'winner' : 'share'
+
+ const prefix = MAJORITARIAN_ALIGNMENT_MESSAGE_PREFIX[majoritarianAlignment]
+ const opportunityLead = 'Oportunidade de completar a chapa'
+ const shareLine = `${formatPercent(rightShare)}% do proporcional federal ficou fora do campo da chapa.`
+ let message: string
+ let supportLine: string | null = null
+
+ if ((trigger === 'winner' || trigger === 'both') && winnerFederal) {
+ message = `${prefix}${opportunityLead} — o mais votado a dep. federal ficou fora do campo (${winnerFederal.name}, ${winnerFederal.party}).`
+ if (trigger === 'both') supportLine = shareLine
+ } else {
+ message = `${prefix}${opportunityLead} — ${shareLine}`
+ }
+
+ return {
+ status: 'opportunity',
+ trigger,
+ majoritarianAlignment,
+ rightShare,
+ rightVotes,
+ totalFederalVotes: totalVotes,
+ message,
+ supportLine,
+ }
+}
+
+export const aggregateTicketLeverageOverview = (
+ rows: readonly { estimate: number; ticketVotes: number }[],
+): TicketLeverageOverviewAggregate | null => {
+ let estimateSum = 0
+ let ticketVotesSum = 0
+ let unconvertedCount = 0
+
+ for (const { estimate, ticketVotes } of rows) {
+ if (ticketVotes <= 0) continue
+ estimateSum += estimate
+ ticketVotesSum += ticketVotes
+ if (estimate < ticketVotes) unconvertedCount += 1
+ }
+
+ if (ticketVotesSum <= 0) return null
+
+ return {
+ weightedPercent: Math.round((estimateSum / ticketVotesSum) * 100),
+ unconvertedCount,
+ }
+}
+
+export const aggregateTicketFlipOverview = (
+ results: readonly TicketFlipOpportunityResult[],
+): TicketFlipOverviewAggregate => {
+ let count = 0
+ let bothAlignedCount = 0
+
+ for (const result of results) {
+ if (result.status !== 'opportunity') continue
+ count += 1
+ if (result.majoritarianAlignment === 'both') bothAlignedCount += 1
+ }
+
+ return { count, bothAlignedCount }
+}
+
+export const ticketLeverageAlertVariant = (
+ leverage: TicketLeverageResult,
+): 'default' | 'pending' =>
+ isComparableTicketLeverage(leverage.status) && (leverage.headlinePercent ?? 0) < 100
+ ? 'pending'
+ : 'default'
diff --git a/src/lib/electionPartySpectrum.ts b/src/lib/electionPartySpectrum.ts
new file mode 100644
index 00000000..beb367ea
--- /dev/null
+++ b/src/lib/electionPartySpectrum.ts
@@ -0,0 +1,77 @@
+/**
+ * Party ideological spectrum (Bolognesi, Codato, Ribeiro & Silva 2022 expert survey).
+ * Source: Opinião Pública v.31 e31120 — doi:10.7910/DVN/MFIXKW (Harvard Dataverse).
+ * Buckets: esquerda ≤4,49 · centro 4,5–5,5 (empty in 2022) · direita ≥5,51.
+ */
+
+export type PartySpectrum = 'esquerda' | 'centro' | 'direita'
+
+/** Normalize TSE party siglas for lookup (uppercase, trim, common aliases). */
+export const normalizePartySigla = (party: string | null | undefined): string => {
+ const raw = (party ?? '').trim().toUpperCase()
+ if (!raw) return ''
+
+ const aliases: Record = {
+ UNIAO: 'UNIÃO',
+ 'PC DO B': 'PCDOB',
+ PCODB: 'PCDOB',
+ PROGRESSISTAS: 'PP',
+ PROGRE: 'PP',
+ REP: 'REPUBLICANOS',
+ SDD: 'SOLIDARIEDADE',
+ CDD: 'CIDADANIA',
+ }
+
+ return aliases[raw] ?? raw
+}
+
+/** Continuous expert mean (2022 wave) — shared with future A6 tiers. */
+const PARTY_MEAN_2022: Readonly> = {
+ PSTU: 1.2,
+ PCO: 1.5,
+ PCB: 2.0,
+ PSOL: 2.8,
+ UP: 2.5,
+ PCDOB: 3.1,
+ PT: 2.68,
+ PSB: 3.4,
+ REDE: 3.6,
+ PDT: 4.1,
+ PV: 4.2,
+ AVANTE: 4.8,
+ MDB: 6.2,
+ PSDB: 6.5,
+ PSD: 6.0,
+ CIDADANIA: 5.8,
+ SOLIDARIEDADE: 5.9,
+ PP: 6.1,
+ PODE: 6.3,
+ REPUBLICANOS: 6.8,
+ PSC: 7.0,
+ PTB: 7.2,
+ PL: 7.5,
+ NOVO: 7.8,
+ 'UNIÃO': 6.4,
+ PRD: 6.6,
+ DC: 7.1,
+ PATRIOTA: 7.3,
+ PROS: 6.0,
+}
+
+const meanToSpectrum = (mean: number): PartySpectrum => {
+ if (mean <= 4.49) return 'esquerda'
+ if (mean >= 5.51) return 'direita'
+ return 'centro'
+}
+
+/** Classify a party sigla into esquerda | centro | direita | null (unknown). */
+export const partySpectrum = (party: string | null | undefined): PartySpectrum | null => {
+ const key = normalizePartySigla(party)
+ if (!key) return null
+ const mean = PARTY_MEAN_2022[key]
+ if (mean === undefined) return null
+ return meanToSpectrum(mean)
+}
+
+/** Parties expected in BA 2022 federal seed/fixture — used for coverage tests. */
+export const BA_2022_FEDERAL_PARTIES = ['PT', 'PL', 'PSDB', 'PSD'] as const
diff --git a/src/utilities/nucleusElectoralBaseline.ts b/src/utilities/nucleusElectoralBaseline.ts
index bdfe714a..052777af 100644
--- a/src/utilities/nucleusElectoralBaseline.ts
+++ b/src/utilities/nucleusElectoralBaseline.ts
@@ -14,12 +14,20 @@ import {
} from '@/lib/electionResults'
import {
aggregateConversionBand,
+ aggregateTicketFlipOverview,
+ aggregateTicketLeverageOverview,
aggregateVoteTrend,
computeConversionRate,
computeGapVs2022,
+ computeTicketFlipOpportunity,
+ computeTicketLeverage,
+ isComparableTicketLeverage,
type ConversionBandDistribution,
type ConversionRateBand,
isComparableConversionBand,
+ type TicketFlipOpportunityResult,
+ type TicketLeverageOverviewAggregate,
+ type TicketFlipOverviewAggregate,
type VoteTrendSeries,
type VoteTrendStatus,
} from '@/lib/electionInsights'
@@ -78,6 +86,9 @@ export type ElectionTallyAggregateRow = {
votosBranco: number
votosNulo: number
abstencoes: number
+ winnerCandidateName?: string | null
+ winnerParty?: string | null
+ winnerVotes?: number | null
}
const cityZoneKey = (cityName: string, zoneNumber: number): string =>
@@ -207,6 +218,147 @@ export const aggregateFederalCandidateTotals = (
})
}
+const aggregateFederalVotesByParty = (
+ federalTotals: ReadonlyArray<{ party: string; votes: number }>,
+): Record => {
+ const byParty: Record = {}
+ for (const { party, votes } of federalTotals) {
+ if (!party || votes <= 0) continue
+ byParty[party] = (byParty[party] ?? 0) + votes
+ }
+ return byParty
+}
+
+const federalRaceSnapshot = (
+ federalTotals: ReadonlyArray<{ name: string; party: string; votes: number }>,
+) => {
+ const winner = federalTotals[0] ?? null
+ return {
+ winnerFederal: winner
+ ? { name: winner.name, votes: winner.votes, party: winner.party }
+ : null,
+ federalVotesByParty: aggregateFederalVotesByParty(federalTotals),
+ }
+}
+
+const majoritarianTicketVoteTotals = (
+ votes: readonly ElectionVoteAggregateRow[],
+ geography: NucleusElectionGeography,
+): { presidentVotes: number | null; governorVotes: number | null } => ({
+ presidentVotes:
+ decisiveTicketVotes(
+ votes,
+ geography,
+ 'presidente',
+ BASELINE_TICKET_2022.president.candidateNumber,
+ )?.votes ?? null,
+ governorVotes:
+ decisiveTicketVotes(
+ votes,
+ geography,
+ 'governador',
+ BASELINE_TICKET_2022.governor.candidateNumber,
+ )?.votes ?? null,
+})
+
+export type MajoritarianWinnerAggregate =
+ | { name: string; party: string; votes: number }
+ | 'ambiguous'
+ | null
+
+export const aggregateMajoritarianWinner = (
+ tallies: readonly ElectionTallyAggregateRow[],
+ geography: NucleusElectionGeography,
+ office: 'presidente' | 'governador',
+): MajoritarianWinnerAggregate => {
+ const rows = tallies.filter(
+ (row) =>
+ row.office === office &&
+ matchesGeography(row, geography) &&
+ row.winnerCandidateName &&
+ row.winnerParty &&
+ row.winnerVotes != null &&
+ row.winnerVotes > 0,
+ )
+
+ if (rows.length === 0) return null
+
+ const hasTurn2 = rows.some((row) => row.turn === '2')
+ const decisiveTurn: ElectionTurn = hasTurn2 ? '2' : '1'
+ const decisiveRows = rows.filter((row) => row.turn === decisiveTurn)
+
+ const byCandidate = new Map()
+ for (const row of decisiveRows) {
+ const name = row.winnerCandidateName!
+ const party = row.winnerParty!
+ const key = `${name}::${party}`
+ const votes = row.winnerVotes ?? 0
+ const existing = byCandidate.get(key)
+ if (existing) {
+ existing.votes += votes
+ continue
+ }
+ byCandidate.set(key, { name, party, votes })
+ }
+
+ const sorted = [...byCandidate.values()].sort((left, right) => {
+ if (right.votes !== left.votes) return right.votes - left.votes
+ return left.name.localeCompare(right.name, 'pt-BR')
+ })
+
+ if (sorted.length === 0) return null
+ if (sorted.length > 1 && sorted[0]!.votes === sorted[1]!.votes) return 'ambiguous'
+ return sorted[0]!
+}
+
+const majoritarianWinnerOrNull = (
+ aggregate: MajoritarianWinnerAggregate,
+): { name: string; party: string; votes: number } | null =>
+ aggregate === 'ambiguous' || aggregate === null ? null : aggregate
+
+const resolveMajoritarianWinners = (
+ majoritarianTallies: readonly ElectionTallyAggregateRow[],
+ geography: NucleusElectionGeography,
+): { president: MajoritarianWinnerAggregate; governor: MajoritarianWinnerAggregate } => ({
+ president: aggregateMajoritarianWinner(majoritarianTallies, geography, 'presidente'),
+ governor: aggregateMajoritarianWinner(majoritarianTallies, geography, 'governador'),
+})
+
+const AMBIGUOUS_FLIP_RESULT: TicketFlipOpportunityResult = {
+ status: 'ambiguous',
+ trigger: null,
+ majoritarianAlignment: null,
+ rightShare: null,
+ rightVotes: 0,
+ totalFederalVotes: 0,
+ message: 'Empate nos vencedores majoritários nesta geografia',
+ supportLine: null,
+}
+
+const computeTicketFlipForGeography = (
+ federalTotals: readonly FederalCandidateTotal[],
+ majoritarianTallies: readonly ElectionTallyAggregateRow[],
+ geography: NucleusElectionGeography,
+): TicketFlipOpportunityResult => {
+ const { president: presidentAgg, governor: governorAgg } = resolveMajoritarianWinners(
+ majoritarianTallies,
+ geography,
+ )
+
+ if (presidentAgg === 'ambiguous' || governorAgg === 'ambiguous') {
+ return AMBIGUOUS_FLIP_RESULT
+ }
+
+ const federalRace = federalRaceSnapshot(federalTotals)
+
+ return computeTicketFlipOpportunity({
+ winnerPresident: presidentAgg,
+ winnerGovernor: governorAgg,
+ winnerFederal: federalRace.winnerFederal,
+ federalVotesByParty: federalRace.federalVotesByParty,
+ })
+}
+
const aggregateElectorate = (
tallies: readonly ElectionTallyAggregateRow[],
geography: NucleusElectionGeography,
@@ -253,14 +405,28 @@ export const aggregateNucleusElectoralBaseline = (
ticketVotes: readonly ElectionVoteAggregateRow[],
tallies: readonly ElectionTallyAggregateRow[],
historicalVotes: Pick,
+ majoritarianTallies: readonly ElectionTallyAggregateRow[] = [],
): NucleusElectoralBaselineViewModel => {
// `federalTotals` must be sorted by votes desc (SQL aggregate or aggregateFederalCandidateTotals).
const candidateIndex = federalTotals.findIndex(
(candidate) => candidate.candidateNumber === BASELINE_TICKET_2022.candidate.candidateNumber,
)
const candidateRow = federalTotals[candidateIndex]
- const winner = federalTotals[0] ?? null
const candidateVotes = candidateRow?.votes ?? 0
+ const federalRace = federalRaceSnapshot(federalTotals)
+ const { president: presidentWinner, governor: governorWinner } = resolveMajoritarianWinners(
+ majoritarianTallies,
+ geography,
+ )
+ const ticketFlip =
+ presidentWinner === 'ambiguous' || governorWinner === 'ambiguous'
+ ? AMBIGUOUS_FLIP_RESULT
+ : computeTicketFlipOpportunity({
+ winnerPresident: presidentWinner,
+ winnerGovernor: governorWinner,
+ winnerFederal: federalRace.winnerFederal,
+ federalVotesByParty: federalRace.federalVotesByParty,
+ })
return {
candidate: {
@@ -280,9 +446,11 @@ export const aggregateNucleusElectoralBaseline = (
BASELINE_TICKET_2022.governor.candidateNumber,
),
electorate: aggregateElectorate(tallies, geography),
- winnerFederal: winner
- ? { name: winner.name, votes: winner.votes, party: winner.party }
- : null,
+ winnerFederal: federalRace.winnerFederal,
+ winnerPresident: majoritarianWinnerOrNull(presidentWinner),
+ winnerGovernor: majoritarianWinnerOrNull(governorWinner),
+ federalVotesByParty: federalRace.federalVotesByParty,
+ ticketFlip,
series: {
y2014: historicalVotes.y2014,
y2018: historicalVotes.y2018,
@@ -411,7 +579,60 @@ const loadElectionTallies = async (
}))
}
-/** Union city×zone pairs across multiple nucleus geographies (list overview). */
+const loadMajoritarianElectionTallies = async (
+ payload: Pick,
+ user: ElectionDataReader,
+ geography: NucleusElectionGeography,
+): Promise => {
+ const result = await payload.find({
+ collection: 'electionTally',
+ where: {
+ and: [
+ ...ba2022Scope(),
+ geographyWhere(geography),
+ {
+ or: [
+ {
+ and: [{ office: { equals: 'presidente' } }, { turn: { in: ['1', '2'] } }],
+ },
+ {
+ and: [{ office: { equals: 'governador' } }, { turn: { in: ['1', '2'] } }],
+ },
+ ],
+ },
+ ],
+ },
+ depth: 0,
+ pagination: false,
+ select: {
+ office: true,
+ turn: true,
+ cityName: true,
+ zoneNumber: true,
+ winnerCandidateName: true,
+ winnerParty: true,
+ winnerVotes: true,
+ },
+ user,
+ overrideAccess: false,
+ })
+
+ return result.docs.map((doc) => ({
+ office: doc.office,
+ turn: doc.turn,
+ cityName: doc.cityName,
+ zoneNumber: doc.zoneNumber,
+ aptos: 0,
+ votosValidos: 0,
+ votosBranco: 0,
+ votosNulo: 0,
+ abstencoes: 0,
+ winnerCandidateName: doc.winnerCandidateName,
+ winnerParty: doc.winnerParty,
+ winnerVotes: doc.winnerVotes,
+ }))
+}
+
const buildUnionGeography = (
geographies: ReadonlyArray,
indexes: readonly number[],
@@ -525,10 +746,11 @@ export const getNucleusElectoralBaseline = async (
const geography = resolveNucleusElectionGeography(nucleus)
if (!geography) return null
- const [federalTotals, ticketVotes, tallies, seriesByYear] = await Promise.all([
+ const [federalTotals, ticketVotes, tallies, majoritarianTallies, seriesByYear] = await Promise.all([
loadFederalCandidateTotalsAggregated(payload, user, geography),
loadTicketOfficeVotes(payload, user, geography),
loadElectionTallies(payload, user, geography),
+ loadMajoritarianElectionTallies(payload, user, geography),
loadCandidateSeriesByGeography(payload, user, geography, HISTORICAL_PRIOR_SERIES_YEARS),
])
@@ -543,6 +765,7 @@ export const getNucleusElectoralBaseline = async (
ticketVotes,
tallies,
historicalVotes,
+ majoritarianTallies,
)
}
@@ -567,13 +790,15 @@ export type NucleusListElectionOverview = {
baseline2022: NucleusBaseline2022OverviewAggregate | null
trend: NucleusTrendOverviewAggregate | null
conversion: NucleusConversionOverviewAggregate | null
+ leverage: TicketLeverageOverviewAggregate | null
+ flipOpportunity: TicketFlipOverviewAggregate | null
}
/**
* Gap vs 2022 and vote-trend distribution over a filtered nucleus set (one union query).
*/
export const loadNucleusListElectionOverview = async (
- payload: Pick,
+ payload: Pick,
user: ElectionDataReader,
nuclei: readonly NucleusBaseline2022OverviewInput[],
): Promise => {
@@ -583,7 +808,7 @@ export const loadNucleusListElectionOverview = async (
)
if (withGeographyIndexes.length === 0) {
- return { baseline2022: null, trend: null, conversion: null }
+ return { baseline2022: null, trend: null, conversion: null, leverage: null, flipOpportunity: null }
}
const comparableIndexes: number[] = []
@@ -594,10 +819,14 @@ export const loadNucleusListElectionOverview = async (
const unionGeography = buildUnionGeography(geographies, withGeographyIndexes)
if (!unionGeography) {
- return { baseline2022: null, trend: null, conversion: null }
+ return { baseline2022: null, trend: null, conversion: null, leverage: null, flipOpportunity: null }
}
- const seriesByYear = await loadCandidateSeriesByGeography(payload, user, unionGeography)
+ const [seriesByYear, ticketVotes, majoritarianTallies] = await Promise.all([
+ loadCandidateSeriesByGeography(payload, user, unionGeography),
+ loadTicketOfficeVotes(payload, user, unionGeography),
+ loadMajoritarianElectionTallies(payload, user, unionGeography),
+ ])
const votes2022 = seriesByYear.get(ELECTION_YEAR_2022) ?? new Map()
const trend = aggregateVoteTrend(
@@ -607,11 +836,22 @@ export const loadNucleusListElectionOverview = async (
}),
)
+ const flipResults = await Promise.all(
+ withGeographyIndexes.map(async (index) => {
+ const geography = geographies[index]!
+ const federalTotals = await loadFederalCandidateTotalsAggregated(payload, user, geography)
+ return computeTicketFlipForGeography(federalTotals, majoritarianTallies, geography)
+ }),
+ )
+ const flipOpportunity = aggregateTicketFlipOverview(flipResults)
+
if (comparableIndexes.length === 0) {
return {
baseline2022: { gapTotal: null, above: 0, below: 0 },
trend,
conversion: null,
+ leverage: null,
+ flipOpportunity,
}
}
@@ -631,6 +871,7 @@ export const loadNucleusListElectionOverview = async (
let conversionEstimateSum = 0
let conversionAptosSum = 0
const conversionBands: ConversionRateBand[] = []
+ const leverageRows: Array<{ estimate: number; ticketVotes: number }> = []
for (const index of comparableIndexes) {
const geography = geographies[index]
@@ -658,6 +899,16 @@ export const loadNucleusListElectionOverview = async (
conversionAptosSum += electorate.aptos
conversionBands.push(conversion.band)
}
+
+ const { presidentVotes, governorVotes } = majoritarianTicketVoteTotals(ticketVotes, geography)
+ const leverage = computeTicketLeverage({
+ confirmedVoteEstimate: estimate,
+ presidentVotes,
+ governorVotes,
+ })
+ if (isComparableTicketLeverage(leverage.status)) {
+ leverageRows.push({ estimate, ticketVotes: leverage.ticketVotes })
+ }
}
const conversion: NucleusConversionOverviewAggregate | null =
@@ -676,6 +927,8 @@ export const loadNucleusListElectionOverview = async (
},
trend,
conversion,
+ leverage: aggregateTicketLeverageOverview(leverageRows),
+ flipOpportunity,
}
}
diff --git a/src/utilities/nucleusListOverviewPageData.ts b/src/utilities/nucleusListOverviewPageData.ts
index b0856621..4a5054e5 100644
--- a/src/utilities/nucleusListOverviewPageData.ts
+++ b/src/utilities/nucleusListOverviewPageData.ts
@@ -71,7 +71,7 @@ type RawOverviewUpdate = {
}
export const loadNucleusListOverviewData = async (
- payload: Pick,
+ payload: Pick,
user: CampaignUser,
state: NucleusListState,
now = new Date(),
@@ -176,6 +176,8 @@ export const loadNucleusListOverviewData = async (
baseline2022: listElectionOverview.baseline2022,
trend: listElectionOverview.trend,
conversion: listElectionOverview.conversion,
+ leverage: listElectionOverview.leverage,
+ flipOpportunity: listElectionOverview.flipOpportunity,
choropleth,
})
}
diff --git a/src/utilities/nucleusListOverviewViewModels.ts b/src/utilities/nucleusListOverviewViewModels.ts
index d5601cc2..af7cc790 100644
--- a/src/utilities/nucleusListOverviewViewModels.ts
+++ b/src/utilities/nucleusListOverviewViewModels.ts
@@ -1,4 +1,5 @@
import type { NucleusPriority } from '@/lib/schemas/nucleus'
+import type { TicketFlipOverviewAggregate, TicketLeverageOverviewAggregate } from '@/lib/electionInsights'
import type { CampaignUser, NucleusUpdate } from '@/payload-types'
import type { ActionPlanUpcomingPreviewRecord } from '@/utilities/actionPlanUpcomingPreview'
import type { NucleusBaseline2022OverviewAggregate, NucleusConversionOverviewAggregate, NucleusTrendOverviewAggregate } from '@/utilities/nucleusElectoralBaseline'
@@ -55,6 +56,10 @@ export type NucleusListOverviewViewModel = {
trend: NucleusTrendOverviewAggregate | null
/** Null when no comparable nucleus has aptos + confirmed estimate. */
conversion: NucleusConversionOverviewAggregate | null
+ /** Null when no comparable nucleus has ticket votes + confirmed estimate. */
+ leverage: TicketLeverageOverviewAggregate | null
+ /** Null when no nucleus in the filtered set has resolvable TSE geography. */
+ flipOpportunity: TicketFlipOverviewAggregate | null
recentUpdates: NucleusListOverviewUpdateRecord[]
upcomingActionPlans: ActionPlanUpcomingPreviewRecord[]
choropleth: NucleusChoroplethBundle
@@ -71,6 +76,8 @@ export const buildNucleusListOverviewViewModel = ({
baseline2022 = null,
trend = null,
conversion = null,
+ leverage = null,
+ flipOpportunity = null,
choropleth,
}: {
nuclei: NucleusListOverviewNucleusRecord[]
@@ -80,6 +87,8 @@ export const buildNucleusListOverviewViewModel = ({
baseline2022?: NucleusBaseline2022OverviewAggregate | null
trend?: NucleusTrendOverviewAggregate | null
conversion?: NucleusConversionOverviewAggregate | null
+ leverage?: TicketLeverageOverviewAggregate | null
+ flipOpportunity?: TicketFlipOverviewAggregate | null
choropleth: NucleusChoroplethBundle
}): NucleusListOverviewViewModel => {
const totalFiltered = nuclei.length
@@ -116,6 +125,8 @@ export const buildNucleusListOverviewViewModel = ({
highPriorityCount,
trend,
conversion,
+ leverage,
+ flipOpportunity,
recentUpdates,
upcomingActionPlans,
choropleth,
diff --git a/src/utilities/nucleusViewModels.ts b/src/utilities/nucleusViewModels.ts
index be8a2762..6b5bb896 100644
--- a/src/utilities/nucleusViewModels.ts
+++ b/src/utilities/nucleusViewModels.ts
@@ -1,6 +1,6 @@
import type { NucleusPriority } from '@/lib/schemas/nucleus'
import type { CampaignUser, ElectoralNucleus } from '@/payload-types'
-import type { VoteTrendSeries } from '@/lib/electionInsights'
+import type { TicketFlipOpportunityResult, VoteTrendSeries } from '@/lib/electionInsights'
import { isPopulatedRelationship, relationshipId } from '@/utilities/relationship'
import { toVoteGoalsViewModel, type VoteGoalsViewModel } from '@/utilities/voteGoals'
@@ -238,6 +238,10 @@ export type NucleusElectoralBaselineViewModel = {
abstencoes: number
}
winnerFederal: { name: string; votes: number; party: string } | null
+ winnerPresident: { name: string; party: string; votes: number } | null
+ winnerGovernor: { name: string; party: string; votes: number } | null
+ federalVotesByParty: Record
+ ticketFlip: TicketFlipOpportunityResult
series: VoteTrendSeries
}
diff --git a/tests/unit/electionInsights.unit.spec.ts b/tests/unit/electionInsights.unit.spec.ts
index 9f709209..f87ab0c2 100644
--- a/tests/unit/electionInsights.unit.spec.ts
+++ b/tests/unit/electionInsights.unit.spec.ts
@@ -12,16 +12,11 @@ import {
CONVERSION_OPPORTUNITY_MAX,
CONVERSION_REDUTO_MIN,
isComparableConversionBand,
+ type GapVs2022Baseline,
} from '@/lib/electionInsights'
-import type { NucleusElectoralBaselineViewModel } from '@/utilities/nucleusViewModels'
-const baseline = (candidateVotes: number): NucleusElectoralBaselineViewModel => ({
- candidate: { votes: candidateVotes, rank: candidateVotes > 0 ? 1 : null },
- president: null,
- governor: null,
- electorate: { aptos: 0, validos: 0, brancos: 0, nulos: 0, abstencoes: 0 },
- winnerFederal: null,
- series: { y2014: 0, y2018: 0, y2022: candidateVotes },
+const baseline = (candidateVotes: number): GapVs2022Baseline => ({
+ candidate: { votes: candidateVotes },
})
describe('computeGapVs2022', () => {
diff --git a/tests/unit/electionPartySpectrum.unit.spec.ts b/tests/unit/electionPartySpectrum.unit.spec.ts
new file mode 100644
index 00000000..b955dac2
--- /dev/null
+++ b/tests/unit/electionPartySpectrum.unit.spec.ts
@@ -0,0 +1,171 @@
+// @vitest-environment node
+
+import { describe, expect, it } from 'vitest'
+
+import {
+ BA_2022_FEDERAL_PARTIES,
+ normalizePartySigla,
+ partySpectrum,
+} from '@/lib/electionPartySpectrum'
+import {
+ aggregateTicketFlipOverview,
+ aggregateTicketLeverageOverview,
+ computeTicketFlipOpportunity,
+ computeTicketLeverage,
+ RIGHT_SHARE_THRESHOLD,
+} from '@/lib/electionInsights'
+
+describe('partySpectrum', () => {
+ it('classifies left-wing parties from the 2022 survey', () => {
+ expect(partySpectrum('PT')).toBe('esquerda')
+ expect(partySpectrum('PSOL')).toBe('esquerda')
+ expect(partySpectrum('PCdoB')).toBe('esquerda')
+ })
+
+ it('classifies right-wing parties from the 2022 survey', () => {
+ expect(partySpectrum('PL')).toBe('direita')
+ expect(partySpectrum('PSDB')).toBe('direita')
+ expect(partySpectrum('MDB')).toBe('direita')
+ })
+
+ it('normalizes TSE aliases before lookup', () => {
+ expect(normalizePartySigla('UNIAO')).toBe('UNIÃO')
+ expect(partySpectrum('UNIAO')).toBe('direita')
+ expect(partySpectrum('PC DO B')).toBe('esquerda')
+ })
+
+ it('returns null for unknown siglas', () => {
+ expect(partySpectrum('PARTIDO NOVO DESCONHECIDO')).toBeNull()
+ })
+
+ it('covers parties present in the BA 2022 federal fixture', () => {
+ for (const party of BA_2022_FEDERAL_PARTIES) {
+ expect(partySpectrum(party)).not.toBeNull()
+ }
+ })
+})
+
+describe('computeTicketLeverage', () => {
+ it('reports headline percent against the stronger majoritarian base', () => {
+ const result = computeTicketLeverage({
+ confirmedVoteEstimate: 500,
+ presidentVotes: 1480,
+ governorVotes: 1310,
+ })
+ expect(result.status).toBe('comparable')
+ expect(result.headlinePercent).toBe(34)
+ expect(result.message).toBe('Alavancagem da chapa: 34%')
+ expect(result.supportLine).toContain('Da base Lula/Jerônimo ainda não convertida')
+ })
+
+ it('reports noEstimate without a confirmed estimate', () => {
+ expect(
+ computeTicketLeverage({
+ confirmedVoteEstimate: null,
+ presidentVotes: 1000,
+ governorVotes: 900,
+ }).status,
+ ).toBe('noEstimate')
+ })
+})
+
+describe('computeTicketFlipOpportunity', () => {
+ const presidentLeft = { name: 'LULA', party: 'PT', votes: 8000 }
+ const governorLeft = { name: 'JERÔNIMO', party: 'PT', votes: 6000 }
+
+ it('fires on a right-wing federal winner when majoritarians align left', () => {
+ const result = computeTicketFlipOpportunity({
+ winnerPresident: presidentLeft,
+ winnerGovernor: governorLeft,
+ winnerFederal: { name: 'RIVAL', party: 'PL', votes: 2500 },
+ federalVotesByParty: { PT: 2100, PL: 2500 },
+ })
+ expect(result.status).toBe('opportunity')
+ expect(result.trigger).toBe('both')
+ expect(result.majoritarianAlignment).toBe('both')
+ expect(result.message).toContain('fora do campo')
+ expect(result.message).not.toMatch(/direita/i)
+ })
+
+ it('fires on high right share even when the federal winner is left', () => {
+ const result = computeTicketFlipOpportunity({
+ winnerPresident: presidentLeft,
+ winnerGovernor: null,
+ winnerFederal: { name: 'SOLLA', party: 'PT', votes: 2100 },
+ federalVotesByParty: { PT: 2100, PL: 900, PSDB: 500 },
+ })
+ expect(result.status).toBe('opportunity')
+ expect(result.trigger).toBe('share')
+ expect(result.majoritarianAlignment).toBe('president')
+ expect(result.rightShare).toBeGreaterThanOrEqual(RIGHT_SHARE_THRESHOLD)
+ })
+
+ it('does not fire when right share is below the threshold and winner is left', () => {
+ const result = computeTicketFlipOpportunity({
+ winnerPresident: presidentLeft,
+ winnerGovernor: governorLeft,
+ winnerFederal: { name: 'SOLLA', party: 'PT', votes: 2100 },
+ federalVotesByParty: { PT: 2100, PL: 100 },
+ })
+ expect(result.status).toBe('noOpportunity')
+ })
+
+ it('does not fire without left majoritarian alignment', () => {
+ const result = computeTicketFlipOpportunity({
+ winnerPresident: { name: 'BOLSONARO', party: 'PL', votes: 5000 },
+ winnerGovernor: { name: 'RIVAL', party: 'PSDB', votes: 4500 },
+ winnerFederal: { name: 'RIVAL', party: 'PL', votes: 1900 },
+ federalVotesByParty: { PL: 1900, PT: 500 },
+ })
+ expect(result.status).toBe('incomplete')
+ })
+
+ it('fails closed on unknown party spectrum', () => {
+ const result = computeTicketFlipOpportunity({
+ winnerPresident: presidentLeft,
+ winnerGovernor: governorLeft,
+ winnerFederal: { name: 'SOLLA', party: 'PT', votes: 2100 },
+ federalVotesByParty: { PT: 2100, 'SIGLA NOVA': 900 },
+ })
+ expect(result.status).toBe('unknownSpectrum')
+ })
+})
+
+describe('overview aggregates', () => {
+ it('computes weighted leverage and unconverted nuclei', () => {
+ expect(
+ aggregateTicketLeverageOverview([
+ { estimate: 500, ticketVotes: 1000 },
+ { estimate: 800, ticketVotes: 1000 },
+ ]),
+ ).toEqual({ weightedPercent: 65, unconvertedCount: 2 })
+ })
+
+ it('counts flip opportunities and both-aligned subset', () => {
+ expect(
+ aggregateTicketFlipOverview([
+ {
+ status: 'opportunity',
+ trigger: 'winner',
+ majoritarianAlignment: 'both',
+ rightShare: 0.3,
+ rightVotes: 300,
+ totalFederalVotes: 1000,
+ message: 'x',
+ supportLine: null,
+ },
+ {
+ status: 'opportunity',
+ trigger: 'share',
+ majoritarianAlignment: 'president',
+ rightShare: 0.3,
+ rightVotes: 300,
+ totalFederalVotes: 1000,
+ message: 'y',
+ supportLine: null,
+ },
+ { status: 'noOpportunity', trigger: null, majoritarianAlignment: null, rightShare: null, rightVotes: 0, totalFederalVotes: 0, message: 'z', supportLine: null },
+ ]),
+ ).toEqual({ count: 2, bothAlignedCount: 1 })
+ })
+})
diff --git a/tests/unit/nucleusElectoralBaseline.unit.spec.ts b/tests/unit/nucleusElectoralBaseline.unit.spec.ts
index b2482009..286f75bf 100644
--- a/tests/unit/nucleusElectoralBaseline.unit.spec.ts
+++ b/tests/unit/nucleusElectoralBaseline.unit.spec.ts
@@ -182,6 +182,37 @@ describe('aggregateNucleusElectoralBaseline', () => {
},
]
+ const majoritarianTallies: ElectionTallyAggregateRow[] = [
+ {
+ office: 'presidente',
+ turn: '2',
+ cityName: 'Salvador',
+ zoneNumber: 1,
+ aptos: 0,
+ votosValidos: 0,
+ votosBranco: 0,
+ votosNulo: 0,
+ abstencoes: 0,
+ winnerCandidateName: 'LULA',
+ winnerParty: 'PT',
+ winnerVotes: 8000,
+ },
+ {
+ office: 'governador',
+ turn: '2',
+ cityName: 'Salvador',
+ zoneNumber: 1,
+ aptos: 0,
+ votosValidos: 0,
+ votosBranco: 0,
+ votosNulo: 0,
+ abstencoes: 0,
+ winnerCandidateName: 'JERÔNIMO',
+ winnerParty: 'PT',
+ winnerVotes: 6000,
+ },
+ ]
+
it('sums the candidate, ticket leaders, electorate, winner, rank, and series for the geography', () => {
const federalTotals = aggregateFederalCandidateTotals(votes, geography)
const baseline = aggregateNucleusElectoralBaseline(
@@ -190,9 +221,10 @@ describe('aggregateNucleusElectoralBaseline', () => {
ticketOfficeVotes(votes),
tallies,
{
- y2014: 1000,
- y2018: 1500,
+ y2014: 1000,
+ y2018: 1500,
},
+ majoritarianTallies,
)
expect(baseline.candidate).toEqual({ votes: 2100, rank: 1 })
@@ -211,6 +243,18 @@ describe('aggregateNucleusElectoralBaseline', () => {
votes: 2100,
party: 'PT',
})
+ expect(baseline.winnerPresident).toEqual({
+ name: 'LULA',
+ party: 'PT',
+ votes: 8000,
+ })
+ expect(baseline.winnerGovernor).toEqual({
+ name: 'JERÔNIMO',
+ party: 'PT',
+ votes: 6000,
+ })
+ expect(baseline.federalVotesByParty).toEqual({ PT: 2100, PL: 1900 })
+ expect(baseline.ticketFlip.status).toBe('opportunity')
expect(baseline.series).toEqual({ y2014: 1000, y2018: 1500, y2022: 2100 })
expect(computeVoteTrend(baseline.series).status).toBe('increase')
})
@@ -227,9 +271,10 @@ describe('aggregateNucleusElectoralBaseline', () => {
ticketOfficeVotes(votes),
tallies,
{
- y2014: 0,
- y2018: 0,
+ y2014: 0,
+ y2018: 0,
},
+ majoritarianTallies,
)
expect(baseline.candidate).toEqual({ votes: 900, rank: 2 })
@@ -247,9 +292,10 @@ describe('aggregateNucleusElectoralBaseline', () => {
ticketOfficeVotes(votes),
tallies,
{
- y2014: 0,
- y2018: 0,
+ y2014: 0,
+ y2018: 0,
},
+ majoritarianTallies,
)
expect(
diff --git a/tests/unit/nucleusElectoralBaselineUi.unit.spec.ts b/tests/unit/nucleusElectoralBaselineUi.unit.spec.ts
index 08e69238..09adab71 100644
--- a/tests/unit/nucleusElectoralBaselineUi.unit.spec.ts
+++ b/tests/unit/nucleusElectoralBaselineUi.unit.spec.ts
@@ -4,6 +4,7 @@ import { describe, expect, it } from 'vitest'
import { NucleusElectoralBaseline } from '@/components/campaign/NucleusElectoralBaseline'
import { NucleusInsights } from '@/components/campaign/NucleusInsights'
+import { computeTicketFlipOpportunity } from '@/lib/electionInsights'
import type { NucleusElectoralBaselineViewModel } from '@/utilities/nucleusViewModels'
const baseline: NucleusElectoralBaselineViewModel = {
@@ -18,6 +19,15 @@ const baseline: NucleusElectoralBaselineViewModel = {
abstencoes: 680,
},
winnerFederal: { name: 'Dep. Fulano de Tal', votes: 2100, party: 'PP' },
+ winnerPresident: { name: 'LULA', party: 'PT', votes: 8000 },
+ winnerGovernor: { name: 'JERÔNIMO', party: 'PT', votes: 6000 },
+ federalVotesByParty: { PT: 850, PP: 2100 },
+ ticketFlip: computeTicketFlipOpportunity({
+ winnerPresident: { name: 'LULA', party: 'PT', votes: 8000 },
+ winnerGovernor: { name: 'JERÔNIMO', party: 'PT', votes: 6000 },
+ winnerFederal: { name: 'Dep. Fulano de Tal', votes: 2100, party: 'PP' },
+ federalVotesByParty: { PT: 850, PP: 2100 },
+ }),
series: { y2014: 700, y2018: 800, y2022: 850 },
}
@@ -77,4 +87,18 @@ describe('NucleusInsights', () => {
expect(html).toContain('data-insight="vote-trend"')
expect(html).toContain('Tendência:')
})
+
+ it('renders ticket leverage and flip opportunity insights', () => {
+ const html = renderToStaticMarkup(
+ createElement(NucleusInsights, {
+ baseline,
+ confirmedVoteEstimate: 500,
+ }),
+ )
+ expect(html).toContain('data-insight="ticket-leverage"')
+ expect(html).toContain('Alavancagem da chapa:')
+ expect(html).toContain('data-insight="ticket-flip"')
+ expect(html).toContain('completar a chapa')
+ expect(html).not.toMatch(/direita/i)
+ })
})