/**
* EqualizationDataContext
* Provides equalization data to visualizer components
*/
'use client';
import React, { createContext, useContext, ReactNode, useMemo, useCallback } from 'react';
import {
equalizationData,
ProvinceEqualizationData,
NationalStandard,
RevenueCategory,
getProvinceEqualizationData,
formatPayment,
formatPerCapita,
isTerritory,
} from '@/lib/visualizer/equalization';
interface EqualizationDataContextType {
/** All province equalization data */
data: Record<string, ProvinceEqualizationData>;
/** National standard values */
nationalStandard: NationalStandard;
/** Revenue categories for the formula */
revenueCategories: RevenueCategory[];
/** Total equalization envelope */
totalEnvelope: number;
/** Get payment amount for a province in millions */
getPaymentAmount: (provinceCode: string) => number;
/** Check if province receives equalization */
isReceivingProvince: (provinceCode: string) => boolean;
/** Get per-capita payment for a province */
getPerCapitaPayment: (provinceCode: string) => number;
/** Get fiscal capacity index for a province */
getFiscalCapacityIndex: (provinceCode: string) => number;
/** Format payment amount for display */
formatPaymentAmount: (amountMillions: number, locale: 'en' | 'fr') => string;
/** Format per-capita amount for display */
formatPerCapitaAmount: (amount: number, locale: 'en' | 'fr') => string;
/** Check if province is a territory */
isProvinceTerritorial: (provinceCode: string) => boolean;
/** Get province data */
getProvinceData: (provinceCode: string) => ProvinceEqualizationData | undefined;
}
const EqualizationDataContext = createContext<EqualizationDataContextType | null>(null);
export function EqualizationDataProvider({ children }: { children: ReactNode }) {
const data = equalizationData.provinces;
const nationalStandard = equalizationData.nationalStandard;
const revenueCategories = equalizationData.revenueCategories;
const totalEnvelope = nationalStandard.totalEnvelopeMillions;
const getPaymentAmount = useCallback((provinceCode: string): number => {
return data[provinceCode]?.paymentMillions ?? 0;
}, [data]);
const isReceivingProvince = useCallback((provinceCode: string): boolean => {
return data[provinceCode]?.isReceiving ?? false;
}, [data]);
const getPerCapitaPayment = useCallback((provinceCode: string): number => {
return data[provinceCode]?.perCapitaPayment ?? 0;
}, [data]);
const getFiscalCapacityIndex = useCallback((provinceCode: string): number => {
return data[provinceCode]?.fiscalCapacityIndex ?? 0;
}, [data]);
const formatPaymentAmount = useCallback((amountMillions: number, locale: 'en' | 'fr'): string => {
return formatPayment(amountMillions, locale);
}, []);
const formatPerCapitaAmount = useCallback((amount: number, locale: 'en' | 'fr'): string => {
return formatPerCapita(amount, locale);
}, []);
const isProvinceTerritorial = useCallback((provinceCode: string): boolean => {
return isTerritory(provinceCode);
}, []);
const getProvinceData = useCallback((provinceCode: string): ProvinceEqualizationData | undefined => {
return getProvinceEqualizationData(provinceCode);
}, []);
const value = useMemo(() => ({
data,
nationalStandard,
revenueCategories,
totalEnvelope,
getPaymentAmount,
isReceivingProvince,
getPerCapitaPayment,
getFiscalCapacityIndex,
formatPaymentAmount,
formatPerCapitaAmount,
isProvinceTerritorial,
getProvinceData,
}), [
data,
nationalStandard,
revenueCategories,
totalEnvelope,
getPaymentAmount,
isReceivingProvince,
getPerCapitaPayment,
getFiscalCapacityIndex,
formatPaymentAmount,
formatPerCapitaAmount,
isProvinceTerritorial,
getProvinceData,
]);
return (
<EqualizationDataContext.Provider value={value}>
{children}
</EqualizationDataContext.Provider>
);
}
export function useEqualizationData() {
const context = useContext(EqualizationDataContext);
if (!context) {
throw new Error('useEqualizationData must be used within an EqualizationDataProvider');
}
return context;
}
